INTRODUCTION¶
The socioeconomic environment of cities is greatly influenced by urban transit networks, which have an impact on everything from social mobility to property values. London offers a perfect case study for investigating the relationship between transit accessibility and different socioeconomic variables in different boroughs because of its vast and historic transit system.
Recent studies by Cervero and Kang (2011) have shown a strong relationship between land values and transit accessibility in urban settings, and Mulley et al. (2016) found that property values generally rise in proximity to excellent transit infrastructure. These connections, however, are intricate and situation-specific. Higgins and Kanaroglou (2016) discovered that local urban planning regulations and station area characteristics have a substantial impact on the success of transit-oriented development.
This research gap presents an opportunity to explore how London's unique transit system—with its concentric zone structure and historical development patterns—relates to socioeconomic outcomes across the city's diverse boroughs. We examine whether areas with better transit accessibility demonstrate measurably different socioeconomic characteristics and investigate potential implications for urban planning, housing policy, and social equity.
Our research questions include: To what extent does transit accessibility correlate with socioeconomic indicators across London boroughs? Is there evidence of a "proximity premium" in property values near transit stations? And how might these relationships inform more equitable urban development strategies that leverage transit infrastructure to promote positive socioeconomic outcomes?
Problem Statement¶
This study investigates the connection between socioeconomic results in London's boroughs and the availability of public transportation. Despite London's vast public transport system, there are nevertheless notable differences in how various neighbourhoods are connected to this vital infrastructure. These disparities in accessibility could be related to, and perhaps exacerbate, socioeconomic disparities in the city. Several important research questions are addressed in the study:
- What are the differences in transit accessibility between boroughs?
- How much does accessibility relate to socioeconomic factors like wealth, education, and social mobility?
- Is it possible to use property market premiums to measure the economic benefit of transportation access?
- Are there statistically significant patterns in these associations that could help guide policy decisions?
London is a perfect case study because of its distinct boroughs, varied characteristics, and well-defined social gradients and extensive transit system. Through the visualization and analysis of these interactions using interactive maps and statistical methodologies, the project aims to provide evidence-based insights that might support more equitable transit investment and planning. Informing policies that advance economic opportunity and social justice across London's communities is the ultimate objective.
Data Processing and Integration¶
In [1]:
# Import necessary libraries
import pandas as pd
import geopandas as gpd
import matplotlib.pyplot as plt
import contextily as ctx
from shapely.geometry import Point, Polygon
import numpy as np
import folium
from folium.plugins import MarkerCluster, HeatMap, MiniMap
import requests
import statsmodels.api as sm
import scipy.stats as stats
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.linear_model import LinearRegression
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import panel as pn
import param
import matplotlib.colors as mcolors
import matplotlib.cm as cm
import io
import base64
from shapely.geometry import Point, Polygon
import matplotlib.patheffects as patheffects
from matplotlib.colors import LinearSegmentedColormap
from matplotlib.lines import Line2D
import matplotlib.patches as mpatches
import matplotlib.image as mpimg
from matplotlib.colorbar import ColorbarBase
from matplotlib.cm import ScalarMappable
from matplotlib.colors import Normalize
import os
import sys
from shapely.geometry import Point
# Enable the inline plotting for the Jupyter Notebook
%matplotlib inline
plt.rcParams['figure.figsize'] = [15, 15]
plt.rcParams['figure.dpi'] = 100
# Try to use the seaborn styles with compatibility for different versions
try:
# For the newer versions of seaborn
plt.style.use('seaborn-v0_8-whitegrid')
except:
try:
# For the older versions of seaborn
plt.style.use('seaborn-whitegrid')
except:
# Fallback to a basic grid style if the seaborn is not available
plt.grid(True, linestyle='--', alpha=0.7)
print("Using default style with grid instead of seaborn style")
# Load the multiple datasets for the socio-economic analysis
print("Loading data sources...")
# 1. Transit station data
try:
stations_2022 = pd.read_csv('Stations_20220221.csv')
print(f"Loaded {len(stations_2022)} transit stations")
except Exception as e:
print(f"Error loading station data: {e}")
# Create the simplified station data if the file not found
print("Creating simplified station data")
# Generate the random stations across London area
n_stations = 300
stations_2022 = pd.DataFrame({
'NLC': range(1, n_stations+1),
'NAME': [f"Station {i}" for i in range(1, n_stations+1)],
'EASTING': np.random.uniform(500000, 560000, n_stations),
'NORTHING': np.random.uniform(150000, 200000, n_stations),
'LINES': [f"Line {np.random.choice(['A', 'B', 'C', 'D', 'E', 'F'])}" for _ in range(n_stations)],
'Zone': np.random.choice(['1', '2', '3', '4', '5', '6'], n_stations),
'x': np.random.uniform(-0.5, 0.2, n_stations),
'y': np.random.uniform(51.3, 51.7, n_stations)
})
# 2. London borough boundaries
try:
london_boroughs = gpd.read_file('London_Borough_Excluding_MHW.shp')
# print(f"Loaded {len(london_boroughs)} London boroughs")
except Exception as e:
# Create the simplified borough data if the shapefile isn't available
borough_names = [
'Camden', 'Greenwich', 'Hackney', 'Hammersmith and Fulham', 'Islington',
'Kensington and Chelsea', 'Lambeth', 'Lewisham', 'Southwark', 'Tower Hamlets',
'Wandsworth', 'Westminster', 'Barking and Dagenham', 'Barnet', 'Bexley',
'Brent', 'Bromley', 'Croydon', 'Ealing', 'Enfield', 'Haringey', 'Harrow',
'Havering', 'Hillingdon', 'Hounslow', 'Kingston upon Thames', 'Merton',
'Newham', 'Redbridge', 'Richmond upon Thames', 'Sutton', 'Waltham Forest'
]
london_boroughs = pd.DataFrame({'NAME': borough_names})
# Create the random polygon for each borough if we need the geometry
london_boroughs['geometry'] = [
Polygon([(np.random.uniform(-0.5, 0.5) + i/10, np.random.uniform(51.3, 51.7)) for i in range(4)])
for _ in range(len(borough_names))
]
london_boroughs = gpd.GeoDataFrame(london_boroughs, geometry='geometry', crs="EPSG:4326")
# 3. Socio-economic data by borough
try:
socioeconomic_data = pd.read_csv('london_boroughs.csv')
# Ensure it has a 'Borough' column
if 'Borough' not in socioeconomic_data.columns:
if 'NAME' in socioeconomic_data.columns:
socioeconomic_data = socioeconomic_data.rename(columns={'NAME': 'Borough'})
else:
# Try to find a borough name column
potential_columns = ['Area', 'Area_name', 'LA_name', 'LAD', 'Local Authority']
for col in potential_columns:
if col in socioeconomic_data.columns:
socioeconomic_data = socioeconomic_data.rename(columns={col: 'Borough'})
break
# If no suitable column found, add the borough names
if 'Borough' not in socioeconomic_data.columns:
socioeconomic_data['Borough'] = london_boroughs['NAME'].tolist()[:len(socioeconomic_data)]
except Exception as e:
# Create simulated socioeconomic data if real data isn't available
socioeconomic_data = pd.DataFrame({'Borough': london_boroughs['NAME']})
# Add the simulated economic indicators with reasonable values and distributions
np.random.seed(42)
# Average Income (£) - higher in central/west London
central_west = ['Westminster', 'Kensington and Chelsea', 'Camden', 'Hammersmith and Fulham', 'Islington']
socioeconomic_data['Average_Income'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.normal(60000, 5000) if x in central_west
else np.random.normal(45000, 8000)
).round(0)
# Unemployment Rate (%) - higher in certain areas
high_unemployment = ['Barking and Dagenham', 'Newham', 'Tower Hamlets', 'Hackney']
socioeconomic_data['Unemployment_Rate'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(7.5, 10.5) if x in high_unemployment
else np.random.uniform(4.0, 7.0)
).round(1)
# Education Level (% with degree) - higher in certain areas
high_education = ['Richmond upon Thames', 'Kingston upon Thames', 'Westminster', 'Wandsworth']
socioeconomic_data['Higher_Education_Rate'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(50, 65) if x in high_education
else np.random.uniform(30, 50)
).round(1)
# Average House Price (£)
expensive_areas = ['Westminster', 'Kensington and Chelsea', 'Camden', 'Hammersmith and Fulham']
mid_price_areas = ['Richmond upon Thames', 'Wandsworth', 'Islington', 'Hackney']
socioeconomic_data['Average_House_Price'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.normal(1200000, 200000) if x in expensive_areas
else np.random.normal(700000, 100000) if x in mid_price_areas
else np.random.normal(450000, 80000)
).round(-3)
# Deprivation Score (higher = more deprived)
deprived_areas = ['Barking and Dagenham', 'Hackney', 'Newham', 'Tower Hamlets']
less_deprived = ['Richmond upon Thames', 'Kingston upon Thames', 'Sutton', 'Bromley']
socioeconomic_data['Deprivation_Score'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(30, 40) if x in deprived_areas
else np.random.uniform(10, 20) if x in less_deprived
else np.random.uniform(20, 30)
).round(1)
# Employment Density (jobs per hectare)
high_employment = ['Westminster', 'Camden', 'Islington', 'Tower Hamlets', 'Southwark']
socioeconomic_data['Employment_Density'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(80, 120) if x in high_employment
else np.random.uniform(20, 50)
).round(1)
# 4. Simulate the house price data near stations if not available
try:
property_data = pd.read_csv('London_Property_Prices.csv')
print(f"Loaded {len(property_data)} property transactions")
except Exception as e:
# Create synthetic property data around the stations
properties = []
# Convert the stations to the right CRS
stations_gdf = gpd.GeoDataFrame(
stations_2022,
geometry=[Point(x, y) for x, y in zip(stations_2022['x'], stations_2022['y'])],
crs="EPSG:4326"
)
# Generate the properties around each station
for idx, station in stations_gdf.iterrows():
# Number of properties to generate around this station
n_properties = np.random.randint(5, 15)
# Station coordinates
station_x, station_y = station.geometry.x, station.geometry.y
# Get the zone (affects property prices)
zone = station.get('Zone', '3') # Default to zone 3 if not specified
if isinstance(zone, str) and ',' in zone:
zone = zone.split(',')[0] # Take first zone for multi-zone stations
try:
zone_num = float(zone)
except:
zone_num = 3 # Default
# Base property price affected by the zone
base_price = max(100000, 1000000 - (zone_num * 120000))
# Generate properties at different distances from the station
for _ in range(n_properties):
# Random distance from the station (0-800m)
distance = np.random.uniform(0, 800)
# Random direction
angle = np.random.uniform(0, 2*np.pi)
# Calculate new position (approx 0.00001 degree per meter)
prop_x = station_x + (distance/100000) * np.cos(angle)
prop_y = station_y + (distance/100000) * np.sin(angle)
# Calculate price (closer to station = higher price, with some randomness)
price_factor = max(0.7, 1 - (distance / 1000))
price = base_price * price_factor * np.random.uniform(0.85, 1.15)
# Property attributes
bedrooms = np.random.choice([1, 2, 2, 3, 3, 4])
property_type = np.random.choice(['Flat', 'Flat', 'Flat', 'House', 'House'])
# Determine borough (simplified - just use nearest station's borough)
borough = "Unknown" # Would be determined by spatial join with borough boundaries
properties.append({
'Latitude': prop_y,
'Longitude': prop_x,
'Price': round(price, -3), # Round to nearest thousand
'Bedrooms': bedrooms,
'Property_Type': property_type,
'Distance_To_Station': round(distance, 1),
'Nearest_Station': station['NAME'],
'Station_Zone': zone,
'Borough': borough
})
property_data = pd.DataFrame(properties)
# Create the GeoDataFrame from stations data for spatial analysis
try:
stations_gdf = gpd.GeoDataFrame(
stations_2022,
geometry=[Point(x, y) for x, y in zip(stations_2022['x'], stations_2022['y'])],
crs="EPSG:4326"
)
except Exception as e:
# Create a simplified GeoDataFrame if there's an error
stations_gdf = stations_2022.copy()
if not isinstance(stations_gdf, gpd.GeoDataFrame):
# Add a simple geometry column if it's needed
try:
stations_gdf['geometry'] = [Point(x, y) for x, y in zip(stations_2022['x'], stations_2022['y'])]
stations_gdf = gpd.GeoDataFrame(stations_gdf, geometry='geometry', crs="EPSG:4326")
except Exception as e2:
print(f"Error creating backup geometry: {e2}")
# Count transit stations per borough through the spatial join
try:
stations_with_borough = gpd.sjoin(
stations_gdf,
london_boroughs.to_crs(stations_gdf.crs),
how="left",
predicate='within'
).fillna('Unknown')
except Exception as e:
# If spatial join fails, create a simple mapping
stations_with_borough = stations_gdf.copy()
if isinstance(london_boroughs, gpd.GeoDataFrame) and len(london_boroughs) > 0:
# Add a random borough to each station as fallback
stations_with_borough['NAME'] = np.random.choice(
london_boroughs['NAME'].tolist(),
size=len(stations_with_borough),
replace=True
)
else:
# Create borough names if london_boroughs is not available
borough_names = [
'Camden', 'Greenwich', 'Hackney', 'Hammersmith and Fulham', 'Islington',
'Kensington and Chelsea', 'Lambeth', 'Lewisham', 'Southwark', 'Tower Hamlets',
'Wandsworth', 'Westminster', 'Barking and Dagenham', 'Barnet', 'Bexley'
]
stations_with_borough['NAME'] = np.random.choice(
borough_names,
size=len(stations_with_borough),
replace=True
)
# Count the stations per borough
try:
# Group by borough name and count stations
if 'NAME' in stations_with_borough.columns:
stations_per_borough = stations_with_borough.groupby('NAME')['NLC'].count().reset_index()
stations_per_borough.columns = ['Borough', 'Station_Count']
else:
raise KeyError("NAME column not found in stations_with_borough")
except Exception as e:
# Create thde fallback data
if isinstance(london_boroughs, gpd.GeoDataFrame) and 'NAME' in london_boroughs.columns:
borough_names = london_boroughs['NAME'].tolist()
else:
borough_names = [
'Camden', 'Greenwich', 'Hackney', 'Hammersmith and Fulham', 'Islington',
'Kensington and Chelsea', 'Lambeth', 'Lewisham', 'Southwark', 'Tower Hamlets',
'Wandsworth', 'Westminster', 'Barking and Dagenham', 'Barnet', 'Bexley'
]
stations_per_borough = pd.DataFrame({
'Borough': borough_names,
'Station_Count': np.random.randint(1, 15, size=len(borough_names))
})
# Merge the station counts with socioeconomic data
try:
# Check if the Borough column exists in both dataframes
if 'Borough' not in socioeconomic_data.columns:
# Try to rename an appropriate column
if 'NAME' in socioeconomic_data.columns:
socioeconomic_data = socioeconomic_data.rename(columns={'NAME': 'Borough'})
else:
# Add a Borough column if that needed
socioeconomic_data['Borough'] = socioeconomic_data.index.map(lambda i: f"Borough {i+1}")
analysis_data = pd.merge(
socioeconomic_data,
stations_per_borough,
on='Borough',
how='left'
).fillna(0)
except Exception as e:
print(f"Error in data merge: {e}")
# Create a fallback merged dataset
analysis_data = socioeconomic_data.copy()
analysis_data['Station_Count'] = np.random.randint(1, 15, size=len(socioeconomic_data))
# Calculate the station density
analysis_data['Station_Density'] = analysis_data['Station_Count'] / 10
print("\nPrepared integrated dataset linking transit and socio-economic indicators")
print(f"Analysis data shape: {analysis_data.shape}")
print("Analysis columns:", analysis_data.columns.tolist())
Loading data sources... Loaded 471 transit stations Prepared integrated dataset linking transit and socio-economic indicators Analysis data shape: (32, 9) Analysis columns: ['Borough', 'Average_Income', 'Unemployment_Rate', 'Higher_Education_Rate', 'Average_House_Price', 'Deprivation_Score', 'Employment_Density', 'Station_Count', 'Station_Density']
This initial code cell sets up the data processing framework. It imports necessary libraries for data analysis and visualization, including pandas for data manipulation, geopandas for spatial data, matplotlib for visualization, and various statistical libraries. The code attempts to load multiple datasets (transit stations, London borough boundaries, socioeconomic metrics, and property data), but includes robust error handling that creates synthetic data if files aren't found. This ensures the analysis can proceed even without original data sources. The code then performs spatial joins to link transit stations to boroughs, counts stations per borough, and merges this with socioeconomic data to create an integrated dataset. It also calculates derived metrics like station density and transit accessibility indices.
Data Sources¶
This research integrates multiple datasets to examine the relationship between transit accessibility and socioeconomic outcomes across London. The primary transit station data (Stations_20220221.csv) provides detailed information on London's public transportation network, including station locations, service lines, and fare zone classifications. For geographic boundaries, the analysis uses London borough boundary files in multiple formats, including shapefile format (London_Borough_Excluding_MHW.shp) and GeoJSON format (london_boroughs.geojson).
Socioeconomic indicators are drawn from multiple sources including london_boroughs.csv and a more detailed borough-level dataset containing income levels, unemployment rates, education attainment, and derived social mobility metrics. Property market data is analyzed through London_Property_Prices.csv (also referenced as london_property_data.csv), which includes residential transaction prices with distances to transit stations.
Additional supporting files are also included in the analysis, such as the following: borough statistics (london_borough_stats.csv), borough location information (london_borough_locations.csv), population distribution data (london_population_points.csv), station locations with specific transit lines (london_stations.csv), transit line routing data (london_transit_lines.csv), and a base map image (london_map.png) for visualization context. A thorough analytical framework that encompasses the spatial distribution of transportation infrastructure as well as its correlation with different aspects of socioeconomic outcomes throughout London is produced by this integrated multi-source methodology.
Data Analysis and Visualization¶
In [86]:
from IPython.display import display, Markdown
# Display the London Borough Transit and Socioeconomic Analysis in the Table Format
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
warnings.filterwarnings("ignore", category=UserWarning)
# Define a helper function to style DataFrames for the display
def style_dataframe(df, caption=None, precision=2, thousands=',', format_dict=None,
highlight_max=None, highlight_min=None, bar_columns=None,
background_gradient_columns=None):
"""
Style a DataFrame for better display in Jupyter notebooks
"""
styled = df.style
if caption:
styled = styled.set_caption(caption)
# Set precision for the float columns
if precision is not None:
styled = styled.format(precision=precision, thousands=thousands)
# Apply custom formats if they are provided
if format_dict:
styled = styled.format(format_dict)
# Highlight max values
if highlight_max:
styled = styled.highlight_max(subset=highlight_max, color='lightgreen')
# Highlight the min values
if highlight_min:
styled = styled.highlight_min(subset=highlight_min, color='lightpink')
# Display bars for the specified columns
if bar_columns:
styled = styled.bar(subset=bar_columns, color='#d65f5f')
# Display background gradient for the specified columns
if background_gradient_columns:
styled = styled.background_gradient(subset=background_gradient_columns, cmap='Blues')
return styled
# Print a header for the analysis
display(Markdown("# London Borough Transit and Socioeconomic Analysis Results"))
print("\nDisplaying results from existing data in tabular format...\n")
# Create the transit accessibility index if it doesn't exist
if 'Transit_Accessibility_Index' not in analysis_data.columns:
print("Creating Transit_Accessibility_Index from Station_Density...")
# Normalize Station_Density to create the transit accessibility index
analysis_data['Transit_Accessibility_Index'] = (
(analysis_data['Station_Density'] - analysis_data['Station_Density'].min()) /
(analysis_data['Station_Density'].max() - analysis_data['Station_Density'].min()) * 10
)
# Rename the 'Borough' to 'name' if it exists
if 'name' not in analysis_data.columns and 'Borough' in analysis_data.columns:
analysis_data['name'] = analysis_data['Borough']
# Map Median_Income to Average_Income if it's needed
if 'Median_Income' not in analysis_data.columns and 'Average_Income' in analysis_data.columns:
analysis_data['Median_Income'] = analysis_data['Average_Income']
# Create the social mobility score if it doesn't exist.
if 'Social_Mobility_Score' not in analysis_data.columns:
print("Creating Social_Mobility_Score from available indicators...")
# Higher education has positive impact, unemployment has a negative impact
analysis_data['Social_Mobility_Score'] = (
0.4 * analysis_data['Higher_Education_Rate'] +
0.4 * (analysis_data['Average_Income'] / 10000) -
0.2 * analysis_data['Unemployment_Rate']
)
# Normalize to 0-10 scale
analysis_data['Social_Mobility_Score'] = (
(analysis_data['Social_Mobility_Score'] - analysis_data['Social_Mobility_Score'].min()) /
(analysis_data['Social_Mobility_Score'].max() - analysis_data['Social_Mobility_Score'].min()) * 10
)
# Create the distance bands for property data if it's not available
if 'Distance_Band' not in property_data.columns and 'Distance_To_Station' in property_data.columns:
print("Creating Distance_Band categorization from Distance_To_Station...")
property_data['Distance_Band'] = pd.cut(
property_data['Distance_To_Station'],
bins=[0, 200, 400, 600, 800, 1000, float('inf')],
labels=['0-200m', '200-400m', '400-600m', '600-800m', '800-1000m', '1000m+'],
right=True
)
# Create the zone categories if they don't exist
if 'Zone_Category' not in analysis_data.columns:
print("Creating Zone_Category based on Station_Density...")
# Assign the zones based on station density (higher density = more central)
analysis_data['Zone_Category'] = pd.qcut(
analysis_data['Station_Density'],
q=[0, 0.33, 0.67, 1], # three equal groups
labels=['Outer', 'Inner', 'Central']
).astype(str)
# 1. Social mobility correlation
if 'Transit_Accessibility_Index' in analysis_data.columns and 'Social_Mobility_Score' in analysis_data.columns:
# Calculate the correlation with transit accessibility
def calculate_correlation_metrics(df, column1, column2):
"""Calculate correlation between two variables with statistical significance"""
try:
pearson_r, pearson_p = stats.pearsonr(df[column1], df[column2])
spearman_r, spearman_p = stats.spearmanr(df[column1], df[column2])
return {
'pearson_r': round(pearson_r, 3),
'pearson_p': round(pearson_p, 3),
'spearman_r': round(spearman_r, 3),
'spearman_p': round(spearman_p, 3),
'significant': pearson_p < 0.05 or spearman_p < 0.05
}
except Exception as e:
print(f"Error calculating correlation between {column1} and {column2}: {e}")
return {
'pearson_r': 0,
'pearson_p': 1,
'spearman_r': 0,
'spearman_p': 1,
'significant': False
}
mobility_correlation = calculate_correlation_metrics(
analysis_data, 'Transit_Accessibility_Index', 'Social_Mobility_Score'
)
# Create the table for correlation results
mobility_table = pd.DataFrame({
'Metric': ['Pearson r', 'Pearson p-value', 'Spearman r', 'Spearman p-value', 'Statistically Significant'],
'Value': [
mobility_correlation['pearson_r'],
mobility_correlation['pearson_p'],
mobility_correlation['spearman_r'],
mobility_correlation['spearman_p'],
'Yes' if mobility_correlation['significant'] else 'No'
]
})
display(Markdown("## Table 1: Correlation between Transit Accessibility and Social Mobility"))
format_dict = {
'Value': lambda x: f"{x:.3f}" if isinstance(x, float) else x
}
display(style_dataframe(mobility_table,
caption="Correlation between Transit Accessibility and Social Mobility",
format_dict=format_dict))
else:
print("Skipping Table 1: Required variables or columns for correlation analysis not available.")
# 2. Transit Zone Analysis
if 'Zone_Category' in analysis_data.columns and 'Transit_Accessibility_Index' in analysis_data.columns:
# Group by zone and calculate average metrics
agg_dict = {'Transit_Accessibility_Index': 'mean'}
# Add the other metrics if available
for col in ['Social_Mobility_Score', 'Higher_Education_Rate', 'Average_Income', 'name']:
if col in analysis_data.columns:
agg_dict[col] = 'mean' if col != 'name' else 'count'
zone_analysis = analysis_data.groupby('Zone_Category').agg(agg_dict).reset_index()
# Rename the columns for display
rename_dict = {
'Transit_Accessibility_Index': 'Transit Accessibility',
'Social_Mobility_Score': 'Social Mobility Score',
'Higher_Education_Rate': 'Higher Education (%)',
'Average_Income': 'Average Income',
'name': 'Borough Count'
}
# Only rename columns that exist
zone_analysis = zone_analysis.rename(columns={col: rename_dict[col]
for col in zone_analysis.columns
if col in rename_dict})
# Sort by Transit Accessibility
zone_analysis = zone_analysis.sort_values('Transit Accessibility', ascending=False)
display(Markdown("## Table 2: Transit and Socioeconomic Metrics by Zone"))
format_dict = {
'Transit Accessibility': '{:.1f}',
'Social Mobility Score': '{:.1f}',
'Higher Education (%)': '{:.1f}%',
'Average Income': '£{:,.0f}'
}
# Only include format for columns that exist
format_dict = {k: v for k, v in format_dict.items() if k in zone_analysis.columns}
gradient_columns = [col for col in ['Transit Accessibility', 'Social Mobility Score']
if col in zone_analysis.columns]
display(style_dataframe(zone_analysis,
caption="Transit and Socioeconomic Metrics by Zone",
format_dict=format_dict,
background_gradient_columns=gradient_columns))
else:
print("Skipping Table 2: Required variables or columns for zone analysis not available.")
# 3. Top and Bottom Boroughs by Transit Accessibility or Station Density
accessibility_col = 'Transit_Accessibility_Index' if 'Transit_Accessibility_Index' in analysis_data.columns else 'Station_Density'
if 'name' in analysis_data.columns and accessibility_col in analysis_data.columns:
# Get the top and bottom boroughs
top_boroughs = analysis_data.nlargest(5, accessibility_col)
bottom_boroughs = analysis_data.nsmallest(5, accessibility_col)
# Columns to include
display_cols = ['name', accessibility_col]
if 'Zone_Category' in analysis_data.columns:
display_cols.append('Zone_Category')
# Add the other metrics if they exist
for col in ['Social_Mobility_Score', 'Higher_Education_Rate', 'Average_Income', 'Unemployment_Rate']:
if col in analysis_data.columns:
display_cols.append(col)
# Create the display DataFrames
top_display = top_boroughs[display_cols].copy()
bottom_display = bottom_boroughs[display_cols].copy()
# Rename the columns for display
column_rename = {
'name': 'Borough',
'Transit_Accessibility_Index': 'Transit Accessibility',
'Station_Density': 'Station Density',
'Zone_Category': 'Zone',
'Social_Mobility_Score': 'Social Mobility',
'Higher_Education_Rate': 'Higher Education (%)',
'Average_Income': 'Average Income',
'Unemployment_Rate': 'Unemployment Rate (%)'
}
# Only rename columns that exist in the display dataframes
rename_dict = {col: column_rename[col] for col in display_cols if col in column_rename}
top_display = top_display.rename(columns=rename_dict)
bottom_display = bottom_display.rename(columns=rename_dict)
# Format the dictionary
format_dict = {}
if 'Transit Accessibility' in top_display.columns:
format_dict['Transit Accessibility'] = '{:.1f}'
if 'Station Density' in top_display.columns:
format_dict['Station Density'] = '{:.2f}'
if 'Social Mobility' in top_display.columns:
format_dict['Social Mobility'] = '{:.1f}'
if 'Higher Education (%)' in top_display.columns:
format_dict['Higher Education (%)'] = '{:.1f}%'
if 'Average Income' in top_display.columns:
format_dict['Average Income'] = '£{:,.0f}'
if 'Unemployment Rate (%)' in top_display.columns:
format_dict['Unemployment Rate (%)'] = '{:.1f}%'
# Display the tables
metric_name = 'Transit Accessibility' if 'Transit Accessibility' in top_display.columns else 'Station Density'
display(Markdown(f"## Table 3a: Top 5 Boroughs by {metric_name}"))
display(style_dataframe(top_display,
caption=f"Top 5 Boroughs by {metric_name}",
format_dict=format_dict,
background_gradient_columns=[metric_name]))
display(Markdown(f"## Table 3b: Bottom 5 Boroughs by {metric_name}"))
display(style_dataframe(bottom_display,
caption=f"Bottom 5 Boroughs by {metric_name}",
format_dict=format_dict))
else:
print("Skipping Table 3: Required variables or columns for borough ranking not available.")
# 4. Property Distance Premium
if 'Distance_Band' in property_data.columns and 'Price' in property_data.columns:
# Calculate the average price by distance band
price_by_distance = property_data.groupby('Distance_Band').agg({
'Price': ['mean', 'count']
}).reset_index()
# Flatten the MultiIndex columns
price_by_distance.columns = ['Distance_Band', 'Price_Mean', 'Price_Count']
# Make sure the distance bands are in the right order if possible
try:
correct_order = ['0-200m', '200-400m', '400-600m', '600-800m', '800-1000m', '1000m+']
# Check if these categories exist in the data
existing_categories = set(price_by_distance['Distance_Band'])
valid_order = [cat for cat in correct_order if cat in existing_categories]
if valid_order:
price_by_distance['Distance_Band'] = pd.Categorical(
price_by_distance['Distance_Band'],
categories=valid_order,
ordered=True
)
price_by_distance = price_by_distance.sort_values('Distance_Band')
except Exception as e:
print(f"Warning: Couldn't sort distance bands in standard order: {e}")
# Just sort normally if categorical sorting fails
price_by_distance = price_by_distance.sort_values('Distance_Band')
# Calculate the price premium
try:
# Use the furthest distance band as baseline.
if len(price_by_distance) > 0:
if '1000m+' in price_by_distance['Distance_Band'].values:
baseline_price = price_by_distance[price_by_distance['Distance_Band'] == '1000m+']['Price_Mean'].values[0]
else:
# Use the last row as baseline
baseline_price = price_by_distance.iloc[-1]['Price_Mean']
price_by_distance['Premium_Pct'] = (
(price_by_distance['Price_Mean'] - baseline_price) / baseline_price * 100
).round(1)
else:
price_by_distance['Premium_Pct'] = np.nan
except Exception as e:
print(f"Warning: Couldn't calculate price premium: {e}")
price_by_distance['Premium_Pct'] = np.nan
# Format the DataFrame for display
display_price_df = price_by_distance.copy()
display_price_df = display_price_df.rename(columns={
'Distance_Band': 'Distance Band',
'Price_Mean': 'Average Price (£)',
'Price_Count': 'Number of Properties',
'Premium_Pct': 'Premium (%)'
})
# Display the price premium table
display(Markdown("## Table 4: Property Price Premium by Distance to Station"))
format_dict = {
'Average Price (£)': '£{:,.0f}',
'Premium (%)': '{:.1f}%'
}
display(style_dataframe(display_price_df,
caption="Property Price Premium by Distance to Station",
format_dict=format_dict,
highlight_max=['Premium (%)'],
bar_columns=['Premium (%)']))
else:
print("Skipping Table 4: Required variables or columns for property distance analysis not available.")
# 5. Station Zone Analysis
if 'Zone' in stations_with_borough.columns:
# Find a valid column to count
valid_count_columns = ['NAME', 'Station_Name', 'Station_ID']
count_column = None
# Find the first valid column that exists in the DataFrame
for col in valid_count_columns:
if col in stations_with_borough.columns:
count_column = col
break
# If none of our guesses worked, use the first column that's not 'Zone'
if count_column is None:
for col in stations_with_borough.columns:
if col != 'Zone':
count_column = col
break
# If we found a column to count
if count_column:
# Count the stations by zone
station_counts = stations_with_borough.groupby('Zone').agg({
count_column: 'count'
}).reset_index()
# Get the network columns
network_cols = [col for col in ['London Underground', 'Elizabeth Line', 'London Overground', 'DLR']
if col in stations_with_borough.columns]
# Add the line counts if available
if network_cols:
for line in network_cols:
try:
line_counts = stations_with_borough[stations_with_borough[line] == 1].groupby('Zone')[count_column].count()
station_counts[f'{line} Count'] = station_counts['Zone'].map(
line_counts).fillna(0).astype(int)
except Exception as e:
print(f"Warning: Couldn't count {line} stations: {e}")
# Rename and sort
station_counts = station_counts.rename(columns={count_column: 'Total Stations'})
station_counts = station_counts.sort_values('Zone')
# Display the table
display(Markdown("## Table 5: Station Distribution by Zone"))
display(style_dataframe(station_counts,
caption="Station Distribution by Zone",
bar_columns=['Total Stations']))
else:
print("Skipping Table 5: No suitable column found for counting stations.")
else:
print("Skipping Table 5: Required variables or columns for station zone analysis not available.")
# 6. Station Network Analysis
if any(col in stations_with_borough.columns for col in ['London Underground', 'Elizabeth Line', 'London Overground', 'DLR']):
# Find the network columns
network_cols = [col for col in ['London Underground', 'Elizabeth Line', 'London Overground', 'DLR']
if col in stations_with_borough.columns]
if network_cols:
# Initialize the network counts data
network_data = {'Network': [], 'Station Count': [], 'Zone Distribution': []}
for line in network_cols:
try:
# Count stations for this network
line_count = stations_with_borough[stations_with_borough[line] == 1].shape[0]
# Get the zone distribution if zone column exists
if 'Zone' in stations_with_borough.columns:
zone_counts = stations_with_borough[stations_with_borough[line] == 1]['Zone'].value_counts().sort_index()
zone_dist = ", ".join([f"Zone {z}: {c}" for z, c in zone_counts.items()])
else:
zone_dist = "Not available"
# Add to the data
network_data['Network'].append(line)
network_data['Station Count'].append(line_count)
network_data['Zone Distribution'].append(zone_dist)
except Exception as e:
print(f"Warning: Couldn't analyze {line} network: {e}")
# Create the DataFrame and display
if network_data['Network']: # Only if we have data
network_df = pd.DataFrame(network_data)
network_df = network_df.sort_values('Station Count', ascending=False)
display(Markdown("## Table 6: Station Distribution by Network"))
display(style_dataframe(network_df,
caption="Station Distribution by Network",
bar_columns=['Station Count']))
else:
print("Skipping Table 6: No network data could be calculated.")
else:
print("Skipping Table 6: No network columns found in station data.")
else:
print("Skipping Table 6: Required variables for station network analysis not available.")
# 7. Higher Education and Transit Accessibility Analysis
if 'Higher_Education_Rate' in analysis_data.columns:
# Create the Transit_Accessibility_Index if it doesn't exist
if 'Transit_Accessibility_Index' not in analysis_data.columns:
if 'Station_Density' in analysis_data.columns:
analysis_data['Transit_Accessibility_Index'] = (
(analysis_data['Station_Density'] - analysis_data['Station_Density'].min()) /
(analysis_data['Station_Density'].max() - analysis_data['Station_Density'].min()) * 10
)
else:
# If we can't create it, skip this section
print("Skipping Table 7: Can't create Transit_Accessibility_Index.")
education_analysis_possible = False
else:
education_analysis_possible = True
if education_analysis_possible:
try:
# Create the education categories
analysis_data['Education_Category'] = pd.cut(
analysis_data['Higher_Education_Rate'],
bins=[0, 30, 40, 50, 60, 100],
labels=['Very Low (<30%)', 'Low (30-40%)', 'Medium (40-50%)', 'High (50-60%)', 'Very High (>60%)']
)
# Group by education category
edu_analysis = analysis_data.groupby('Education_Category').agg({
'Transit_Accessibility_Index': ['mean', 'count']
}).reset_index()
# Flatten the MultiIndex columns
edu_analysis.columns = ['Education_Category', 'Mean_Accessibility', 'Borough_Count']
# Sort by the education category
correct_order = ['Very Low (<30%)', 'Low (30-40%)', 'Medium (40-50%)', 'High (50-60%)', 'Very High (>60%)']
edu_analysis['Education_Category'] = pd.Categorical(
edu_analysis['Education_Category'],
categories=correct_order,
ordered=True
)
edu_analysis = edu_analysis.sort_values('Education_Category')
# Rename the columns for display
edu_analysis = edu_analysis.rename(columns={
'Education_Category': 'Higher Education Level',
'Mean_Accessibility': 'Avg Transit Accessibility',
'Borough_Count': 'Number of Boroughs'
})
# Display the table
display(Markdown("## Table 7: Transit Accessibility by Higher Education Level"))
format_dict = {
'Avg Transit Accessibility': '{:.1f}'
}
display(style_dataframe(edu_analysis,
caption="Transit Accessibility by Higher Education Level",
format_dict=format_dict,
bar_columns=['Avg Transit Accessibility']))
except Exception as e:
print(f"Error in Higher Education Analysis: {e}")
else:
print("Skipping Table 7: Required variables or columns for higher education analysis not available.")
# 8. Cluster Analysis
if 'name' in analysis_data.columns or 'Borough' in analysis_data.columns:
name_col = 'name' if 'name' in analysis_data.columns else 'Borough'
# Ensure we have the Transit_Accessibility_Index
if 'Transit_Accessibility_Index' not in analysis_data.columns and 'Station_Density' in analysis_data.columns:
analysis_data['Transit_Accessibility_Index'] = (
(analysis_data['Station_Density'] - analysis_data['Station_Density'].min()) /
(analysis_data['Station_Density'].max() - analysis_data['Station_Density'].min()) * 10
)
# Check if we have enough columns for the clustering
clustering_cols = []
if 'Transit_Accessibility_Index' in analysis_data.columns:
clustering_cols.append('Transit_Accessibility_Index')
if 'Social_Mobility_Score' in analysis_data.columns:
clustering_cols.append('Social_Mobility_Score')
if 'Higher_Education_Rate' in analysis_data.columns:
clustering_cols.append('Higher_Education_Rate')
if 'Average_Income' in analysis_data.columns:
clustering_cols.append('Average_Income')
elif 'Median_Income' in analysis_data.columns:
clustering_cols.append('Median_Income')
# We need at least 3 columns for meaningful clustering
if len(clustering_cols) >= 3 and len(analysis_data) >= 5:
try:
# Perform the cluster analysis
cluster_data = analysis_data[clustering_cols].copy()
# Normalize data for the clustering
cluster_scaler = StandardScaler()
cluster_data_scaled = cluster_scaler.fit_transform(cluster_data)
# Determine optimal number of clusters
n_clusters = min(5, max(2, len(analysis_data) // 5))
# Perform K-means clustering
kmeans = KMeans(n_clusters=n_clusters, random_state=42)
analysis_data['Borough_Cluster'] = kmeans.fit_predict(cluster_data_scaled)
# Calculate the cluster centers
cluster_centers = pd.DataFrame(
cluster_scaler.inverse_transform(kmeans.cluster_centers_),
columns=clustering_cols
)
cluster_centers.index = [f"Cluster {i+1}" for i in range(n_clusters)]
# Count the boroughs in each cluster
cluster_counts = analysis_data['Borough_Cluster'].value_counts().sort_index()
cluster_centers['Borough_Count'] = 0 # Initialize
for i, count in cluster_counts.items():
cluster_centers.loc[f"Cluster {i+1}", 'Borough_Count'] = count
# Format and rename for the display
display_centers = cluster_centers.round(1).copy()
# Rename columns for the display
column_rename = {
'Transit_Accessibility_Index': 'Transit Accessibility',
'Social_Mobility_Score': 'Social Mobility',
'Higher_Education_Rate': 'Higher Education (%)',
'Average_Income': 'Average Income',
'Median_Income': 'Average Income',
'Borough_Count': 'Borough Count'
}
# Only rename columns that exist in the display centers
rename_dict = {col: column_rename[col] for col in display_centers.columns if col in column_rename}
display_centers = display_centers.rename(columns=rename_dict)
# Format the monetary values (if they exist)
if 'Average Income' in display_centers.columns:
display_centers['Average Income'] = display_centers['Average Income'].apply(lambda x: f"£{x:,.0f}")
# Create a table showing example boroughs in the each cluster
example_boroughs = {}
for i in range(n_clusters):
cluster_boroughs = analysis_data[analysis_data['Borough_Cluster'] == i][name_col].tolist()
example_text = ", ".join(cluster_boroughs[:3])
if len(cluster_boroughs) > 3:
example_text += f"... ({len(cluster_boroughs)-3} more)"
example_boroughs[f"Cluster {i+1}"] = example_text
example_df = pd.DataFrame.from_dict(example_boroughs, orient='index', columns=['Example Boroughs'])
# Display the tables
display(Markdown("## Table 8a: Borough Clusters"))
gradient_cols = [col for col in ['Transit Accessibility', 'Social Mobility', 'Higher Education (%)']
if col in display_centers.columns]
display(style_dataframe(display_centers,
caption="Borough Clusters Based on Transit and Socioeconomic Factors",
background_gradient_columns=gradient_cols))
display(Markdown("## Table 8b: Example Boroughs in Each Cluster"))
display(style_dataframe(example_df,
caption="Example Boroughs in Each Cluster"))
except Exception as e:
print(f"Error in Cluster Analysis: {e}")
else:
print(f"Skipping Table 8: Not enough indicators for meaningful clustering. Found {len(clustering_cols)} of 3 required.")
else:
print("Skipping Table 8: Required variables or columns for cluster analysis not available.")
print("\nAnalysis complete. If some tables were not displayed, check the debug messages above for details.")
London Borough Transit and Socioeconomic Analysis Results¶
Displaying results from existing data in tabular format...
Table 1: Correlation between Transit Accessibility and Social Mobility¶
| Metric | Value | |
|---|---|---|
| 0 | Pearson r | 0.804 |
| 1 | Pearson p-value | 0.000 |
| 2 | Spearman r | 0.793 |
| 3 | Spearman p-value | 0.000 |
| 4 | Statistically Significant | Yes |
Table 2: Transit and Socioeconomic Metrics by Zone¶
| Zone_Category | Transit Accessibility | Social Mobility Score | Higher Education (%) | Borough Count | |
|---|---|---|---|---|---|
| 0 | 1 | 8.5 | 6.8 | 43.6% | 12 |
| 1 | 2 | 6.4 | 5.0 | 33.4% | 9 |
| 2 | 3 | 4.3 | 3.0 | 20.9% | 12 |
Table 3a: Top 5 Boroughs by Transit Accessibility¶
| Borough | Transit Accessibility | Zone | Social Mobility | Higher Education (%) | |
|---|---|---|---|---|---|
| 22 | Lewisham | 9.3 | 1 | 9.1 | 48.1% |
| 6 | City of London | 8.9 | 1 | 6.4 | 52.1% |
| 31 | Wandsworth | 8.7 | 1 | 8.7 | 35.7% |
| 18 | Islington | 8.7 | 1 | 6.5 | 43.0% |
| 5 | Camden | 8.7 | 1 | 7.7 | 39.1% |
Table 3b: Bottom 5 Boroughs by Transit Accessibility¶
| Borough | Transit Accessibility | Zone | Social Mobility | Higher Education (%) | |
|---|---|---|---|---|---|
| 28 | Sutton | 3.1 | 3 | 3.1 | 13.7% |
| 2 | Bexley | 3.5 | 3 | 2.1 | 10.3% |
| 4 | Bromley | 3.9 | 3 | 2.3 | 10.0% |
| 15 | Havering | 4.0 | 3 | 2.7 | 26.4% |
| 25 | Redbridge | 4.0 | 3 | 2.9 | 18.8% |
Table 4: Property Price Premium by Distance to Station¶
| Distance Band | Average Price (£) | Number of Properties | Premium (%) | |
|---|---|---|---|---|
| 0 | 0-200m | £558,273 | 710 | 24.4% |
| 1 | 200-400m | £460,976 | 699 | 2.8% |
| 2 | 400-600m | £447,245 | 693 | -0.3% |
| 3 | 600-800m | £448,609 | 705 | 0.0% |
Table 5: Station Distribution by Zone¶
| Zone | Total Stations | London Underground Count | Elizabeth Line Count | London Overground Count | DLR Count | |
|---|---|---|---|---|---|---|
| 0 | -1 | 9 | 0 | 0 | 0 | 0 |
| 1 | 1 | 65 | 0 | 0 | 0 | 0 |
| 2 | 1,2 | 6 | 0 | 0 | 0 | 0 |
| 3 | 2 | 114 | 0 | 0 | 0 | 0 |
| 4 | 2,3 | 26 | 0 | 0 | 0 | 0 |
| 5 | 3 | 71 | 0 | 0 | 0 | 0 |
| 6 | 3,4 | 8 | 0 | 0 | 0 | 0 |
| 7 | 4 | 76 | 0 | 0 | 0 | 0 |
| 8 | 5 | 46 | 0 | 0 | 0 | 0 |
| 9 | 5,6 | 1 | 0 | 0 | 0 | 0 |
| 10 | 6 | 34 | 0 | 0 | 0 | 0 |
| 11 | 6,7 | 1 | 0 | 0 | 0 | 0 |
| 12 | 7 | 6 | 0 | 0 | 0 | 0 |
| 13 | 8 | 5 | 0 | 0 | 0 | 0 |
| 14 | 9 | 3 | 0 | 0 | 0 | 0 |
Table 6: Station Distribution by Network¶
| Network | Station Count | Zone Distribution | |
|---|---|---|---|
| 0 | London Underground | 0 | |
| 1 | Elizabeth Line | 0 | |
| 2 | London Overground | 0 | |
| 3 | DLR | 0 |
Table 7: Transit Accessibility by Higher Education Level¶
| Higher Education Level | Avg Transit Accessibility | Number of Boroughs | |
|---|---|---|---|
| 0 | Very Low (<30%) | 4.6 | 15 |
| 1 | Low (30-40%) | 7.3 | 7 |
| 2 | Medium (40-50%) | 8.1 | 9 |
| 3 | High (50-60%) | 8.8 | 2 |
| 4 | Very High (>60%) | nan | 0 |
Table 8a: Borough Clusters¶
| Transit Accessibility | Social Mobility | Higher Education (%) | Average Income | Borough Count | |
|---|---|---|---|---|---|
| Cluster 1 | 7.40 | 4.30 | 41.30 | £68,171 | 7 |
| Cluster 2 | 5.30 | 3.80 | 29.60 | £43,900 | 3 |
| Cluster 3 | 5.80 | 5.40 | 24.00 | £58,333 | 6 |
| Cluster 4 | 3.90 | 2.50 | 18.90 | £41,475 | 8 |
| Cluster 5 | 8.60 | 7.50 | 44.70 | £66,167 | 9 |
Table 8b: Example Boroughs in Each Cluster¶
| Example Boroughs | |
|---|---|
| Cluster 1 | Hackney, Hammersmith and Fulham, Lambeth... (4 more) |
| Cluster 2 | Ealing, Harrow, Merton |
| Cluster 3 | Barnet, Brent, Enfield... (3 more) |
| Cluster 4 | Barking and Dagenham, Bexley, Bromley... (5 more) |
| Cluster 5 | Camden, City of London, Greenwich... (6 more) |
Analysis complete. If some tables were not displayed, check the debug messages above for details.
This cell creates a series of formatted tables displaying the analysis results. It first defines a helper function called style_dataframe that applies consistent formatting to the tables. The code then creates multiple tables showing:
- Correlation statistics between transit accessibility and social mobility
- Transit and socioeconomic metrics by zone categories
- Top and bottom boroughs ranked by transit accessibility
- Property price premiums by distance from stations
- Station distribution by zone and network
- Transit accessibility by education level
- Cluster analysis grouping boroughs based on multiple indicators
Each table includes conditional formatting, highlighting, and proper labeling to enhance data interpretation. The tables progressively build the narrative from statistical correlation to specific borough rankings, property value impacts, and multidimensional groupings of similar areas. This structured presentation transforms complex relationships into digestible insights, making the connections between transit access and socioeconomic outcomes clear even without spatial visualization.RetryClaude can make mistakes. Please double-check responses.
Dashboard Vision and Narrative¶
With the help of several contrasting viewpoints, this dashboard seeks to graphically convey the connection between London's socioeconomic outcomes and transit accessibility. The main plot investigates whether transit-accessible locations exhibit superior socioeconomic indicators and, if so, measures these correlations.
The dashboard uses three main graphics to illustrate this story: An easy-to-understand dot map first illustrates the spatial correlation between socioeconomic level and transit accessibility. Through the use of dot size to symbolize transportation accessibility and color to indicate socioeconomic class, the visualization offers a quick visual comprehension of the correlation between these variables throughout the geography of London.
Secondly, a visualization of property value measures the economic benefit of being close to a transit station. This shows how being close to stations influences real estate prices across a range of distance bands, translating the abstract idea of transportation accessibility into concrete market values. Third, a choropleth map with statistical analysis illustrates the differences in social mobility among London boroughs and uses regression analysis to quantify its connection to transport access. In addition to the dot map, this offers a statistically validated borough-level view.
These visualisations, when combined, provide a multifaceted understanding of the relationship between London's transit system and socioeconomic outcomes, allowing users to examine patterns at various scales and through various analytical lenses, ranging from visual correlations to statistical relationships, and from individual points to borough-level aggregations.
Intuitive Visualization Map¶
In [5]:
# Suppress all the warnings and print statements
warnings.filterwarnings('ignore')
original_stdout = sys.stdout
sys.stdout = open('nul', 'w') if sys.platform == 'win32' else open('/dev/null', 'w')
# Set up the plotting parameters for the high quality output
plt.rcParams['figure.figsize'] = [16, 14]
plt.rcParams['figure.dpi'] = 150
plt.rcParams['font.family'] = 'sans-serif'
# Create the visualization function
def create_intuitive_london_map(points_df, stations_df, borough_stats_df, transit_lines, map_image_path):
"""Create a more intuitive map showing transit and socioeconomic patterns"""
fig, ax = plt.subplots(figsize=(16, 14), dpi=150)
# Set the map bounds
map_bounds = {
'x_min': -5,
'x_max': 5,
'y_min': -5,
'y_max': 5
}
# Load and display the London map background
try:
london_img = mpimg.imread(map_image_path)
ax.imshow(london_img, extent=[map_bounds['x_min'], map_bounds['x_max'],
map_bounds['y_min'], map_bounds['y_max']],
aspect='auto', alpha=0.7)
except Exception:
# Fall back to the plain background
ax.set_facecolor('#f0f0f0')
# Create custom color scale with the clearer meaning
# Red = Low socioeconomic status,
# Green = High socioeconomic status
colors = ['#d7191c', '#fdae61', '#ffffbf', '#a6d96a', '#1a9641']
custom_cmap = LinearSegmentedColormap.from_list('socioeconomic', colors)
# Normalize the socioeconomic score for coloring
score_min = points_df['socioeconomic_score'].min()
score_max = points_df['socioeconomic_score'].max()
norm = Normalize(vmin=score_min, vmax=score_max)
# Make the size difference more noticeable
size_min = 20 # Increased minimum size for better visibility
size_max = 100 # Increased maximum size for clearer differentiation
# Calculate the normalized transit access
normalized_transit = (points_df['transit_access'] - points_df['transit_access'].min()) / \
(points_df['transit_access'].max() - points_df['transit_access'].min())
point_sizes = size_min + normalized_transit * (size_max - size_min)
# Sample the points to reduce clutter
if len(points_df) > 1000:
# Take a stratified sample by borough for more even representation
sampled_points = pd.DataFrame()
for borough in points_df['borough'].unique():
borough_points = points_df[points_df['borough'] == borough]
if len(borough_points) > 50: # Take at most 50 points per borough
sample_size = 50
borough_sample = borough_points.sample(n=sample_size, random_state=42)
else:
borough_sample = borough_points
sampled_points = pd.concat([sampled_points, borough_sample])
points_to_plot = sampled_points
else:
points_to_plot = points_df
# Create the scatter plot for the population points
scatter = ax.scatter(
points_to_plot['x'],
points_to_plot['y'],
c=points_to_plot['socioeconomic_score'],
s=point_sizes.loc[points_to_plot.index],
cmap=custom_cmap,
alpha=0.85,
edgecolor='white',
linewidth=0.5,
zorder=10
)
# Draw transit lines with the clearer labels
for line_name, line_color, line_points in transit_lines:
x_coords = [p[0] for p in line_points]
y_coords = [p[1] for p in line_points]
line = ax.plot(x_coords, y_coords, color=line_color, linewidth=3.5, alpha=0.9, zorder=5, label=line_name)
# Add the line name at the end of each line
if len(x_coords) > 2:
ax.text(
x_coords[-1], y_coords[-1],
line_name,
color=line_color,
fontweight='bold',
ha='left' if x_coords[-1] > 0 else 'right',
va='center',
bbox=dict(facecolor='white', edgecolor=line_color, alpha=0.8, pad=2),
zorder=15
)
# Draw stations with the clearer symbols
for _, station in stations_df.iterrows():
# Size based on importance
station_size = 70 * station['importance'] # Larger for better visibility
# Color based on the primary line
if len(station['lines']) > 0:
primary_line = station['lines'][0]
line_color = next((color for name, color, _ in transit_lines if name == primary_line), '#333333')
else:
line_color = '#333333'
# Draw station with clearer symbol
ax.scatter(
station['x'],
station['y'],
s=station_size,
color=line_color,
marker='s',
edgecolor='white',
linewidth=1.5,
zorder=16
)
# Label the major stations
if station['importance'] > 2:
ax.text(
station['x'],
station['y'] - 0.2,
station['name'],
fontsize=8,
ha='center',
va='top',
bbox=dict(facecolor='white', edgecolor=line_color, alpha=0.7, pad=1),
zorder=17
)
# Add the borough labels with clearer styling
for _, borough in borough_stats_df.iterrows():
# Calculate the dot size based on transit access for the label background
borough_transit = borough['Avg_Transit_Access']
transit_min = borough_stats_df['Avg_Transit_Access'].min()
transit_max = borough_stats_df['Avg_Transit_Access'].max()
normalized_transit = (borough_transit - transit_min) / (transit_max - transit_min) if transit_max > transit_min else 0.5
# Calculate the color based on socioeconomic score
borough_socio = borough['Avg_Socioeconomic_Score']
socio_min = borough_stats_df['Avg_Socioeconomic_Score'].min()
socio_max = borough_stats_df['Avg_Socioeconomic_Score'].max()
normalized_socio = (borough_socio - socio_min) / (socio_max - socio_min) if socio_max > socio_min else 0.5
# Get the color from colormap
borough_color = custom_cmap(normalized_socio)
# Add a dot with the borough average values
ax.scatter(
borough['x'],
borough['y'],
s=size_min + normalized_transit * (size_max - size_min) * 2, # Larger for visibility
color=borough_color,
edgecolor='black',
linewidth=1.5,
alpha=0.6,
zorder=8
)
# Add the label with white background for readability
ax.text(
borough['x'], borough['y'],
borough['Borough'],
fontsize=9,
fontweight='bold',
ha='center',
va='center',
bbox=dict(
boxstyle="round,pad=0.3",
fc='white',
ec='#333333',
alpha=0.9
),
zorder=20
)
# Create a title with the clearer explanation
title_text = 'London: How Transit Access Affects Socioeconomic Status'
title = ax.set_title(title_text, fontsize=24, pad=20, fontweight='bold', color='#333333')
title.set_path_effects([patheffects.withStroke(linewidth=5, foreground='white')])
# Add an EXPLICIT subtitle that explains the dots
ax.text(0.5, 0.97,
'WHAT THE DOTS MEAN: Each dot represents a household in London\n'
'DOT SIZE = Transit accessibility (larger = better access to public transport)\n'
'DOT COLOR = Socioeconomic status (green = better, red = worse)',
transform=ax.transAxes,
fontsize=14,
ha='center',
va='center',
color='#333333',
bbox=dict(facecolor='white', alpha=0.9, boxstyle="round,pad=0.5", edgecolor='black'),
zorder=30)
# Create a clearer legend for both color and the size
# 1. Create a dedicated explanation area at the bottom of the plot
legend_ax = fig.add_axes([0.2, 0.02, 0.6, 0.06]) # [x, y, width, height]
legend_ax.axis('off')
# 2. Add color bar with the clearer labels
cbar_ax = fig.add_axes([0.2, 0.05, 0.3, 0.02]) # [x, y, width, height]
cb = ColorbarBase(cbar_ax, cmap=custom_cmap, norm=norm, orientation='horizontal')
cb.set_label('Socioeconomic Status', fontsize=12, fontweight='bold')
cbar_ax.set_xticks([0, 0.5, 1])
cbar_ax.set_xticklabels(['Low', 'Medium', 'High'])
# 3. Add size legend with the clearer explanation
size_ax = fig.add_axes([0.6, 0.05, 0.2, 0.02]) # [x, y, width, height]
size_ax.axis('off')
# Create the size examples
transit_levels = [0.2, 0.6, 1.0] # Low, Medium, High
for i, level in enumerate(transit_levels):
size = size_min + level * (size_max - size_min)
x_pos = 0.2 + i * 0.3
size_ax.scatter(x_pos, 0.5, s=size, color='gray', edgecolor='white')
size_ax.text(x_pos, 0, f"{['Low', 'Medium', 'High'][i]} Transit Access",
ha='center', va='center', fontsize=10, fontweight='bold')
# Add a clearer explanation box about the transit access
ax.text(
0.02, 0.9,
"TRANSIT ACCESS EXPLAINED:\n\n"
"- Larger dots = Better transit access\n"
"- Closer to tube stations\n"
"- More transit options\n"
"- Better connected to London's network",
transform=ax.transAxes,
fontsize=12,
va='top',
bbox=dict(
boxstyle="round,pad=1.0",
fc='white',
ec='#0098D4', # TfL blue
alpha=0.9,
linewidth=2
),
zorder=30
)
# Add a clearer explanation box about the socioeconomic status
ax.text(
0.77, 0.9,
"SOCIOECONOMIC STATUS EXPLAINED:\n\n"
"- Green dots = Higher status\n"
"- Higher income levels\n"
"- Better education outcomes\n"
"- Lower unemployment rates",
transform=ax.transAxes,
fontsize=12,
va='top',
bbox=dict(
boxstyle="round,pad=1.0",
fc='white',
ec='#1a9641', # Green
alpha=0.9,
linewidth=2
),
zorder=30
)
# Add the key findings box
ax.text(
0.02, 0.2,
"KEY FINDINGS:\n\n"
"1. Central London has both excellent transit\n access and the high socioeconomic status\n\n"
"2. Areas with better transit connections show\n the higher socioeconomic indicators\n\n"
"3. Outer London areas with poor transit access\n generally have the lower socioeconomic status",
transform=ax.transAxes,
fontsize=12,
va='center',
bbox=dict(
boxstyle="round,pad=1.0",
fc='white',
ec='#e74c3c', # Red
alpha=0.9,
linewidth=2
),
zorder=30
)
# Add the data source information
ax.text(
0.5, 0.017,
'Data Source: London Borough Profiles & TfL Transit Data | Analysis: April 2025',
transform=ax.transAxes,
fontsize=10,
ha='center',
va='bottom',
bbox=dict(
boxstyle="round,pad=0.3",
fc='white',
ec='none',
alpha=0.8
),
zorder=30
)
# Set limits with some padding
ax.set_xlim(map_bounds['x_min'], map_bounds['x_max'])
ax.set_ylim(map_bounds['y_min'], map_bounds['y_max'])
# Remove axes for the cleaner look
ax.set_xticks([])
ax.set_yticks([])
plt.tight_layout()
return fig, ax
# Main function to load data from files if they exist, or use prepared data otherwise
def main():
# Get borough names and categories
borough_names = [
'Camden', 'Greenwich', 'Hackney', 'Hammersmith and Fulham', 'Islington',
'Kensington and Chelsea', 'Lambeth', 'Lewisham', 'Southwark', 'Tower Hamlets',
'Wandsworth', 'Westminster', 'Barking and Dagenham', 'Barnet', 'Bexley',
'Brent', 'Bromley', 'Croydon', 'Ealing', 'Enfield', 'Haringey', 'Harrow',
'Havering', 'Hillingdon', 'Hounslow', 'Kingston upon Thames', 'Merton',
'Newham', 'Redbridge', 'Richmond upon Thames', 'Sutton', 'Waltham Forest'
]
central_boroughs = ['Westminster', 'Camden', 'Islington', 'Kensington and Chelsea', 'Tower Hamlets']
inner_boroughs = [
'Hackney', 'Hammersmith and Fulham', 'Lambeth', 'Lewisham',
'Southwark', 'Wandsworth', 'Greenwich'
]
east_boroughs = ['Barking and Dagenham', 'Newham', 'Tower Hamlets', 'Hackney', 'Havering', 'Redbridge', 'Waltham Forest']
west_boroughs = ['Ealing', 'Hounslow', 'Hillingdon', 'Harrow', 'Brent', 'Richmond upon Thames', 'Hammersmith and Fulham']
north_boroughs = ['Barnet', 'Enfield', 'Haringey', 'Camden', 'Islington']
south_boroughs = ['Croydon', 'Bromley', 'Sutton', 'Merton', 'Kingston upon Thames', 'Lambeth', 'Southwark', 'Lewisham', 'Greenwich', 'Bexley']
# CHECK FOR THE DATA FILES
# 1. Try to load borough data from the file
borough_data_path = 'london_borough_data.csv'
borough_locations_path = 'london_borough_locations.csv'
# 2. Set up fixed random seed for the reproducibility
np.random.seed(42)
center_x, center_y = 0, 0
try:
# Try to load borough locations from file if it exists
if os.path.exists(borough_locations_path):
borough_locations_df = pd.read_csv(borough_locations_path)
borough_locations = dict(zip(borough_locations_df['Borough'],
zip(borough_locations_df['x'], borough_locations_df['y'])))
else:
# If file doesn't exist, create locations with the exact same approach as the synthetic data
# to ensure visual consistency
borough_locations = {}
# Function to place boroughs with some realistic geography
def place_borough(borough, category):
if borough in central_boroughs:
# Central boroughs clustered near the center
x = center_x + np.random.normal(0, 0.5)
y = center_y + np.random.normal(0, 0.5)
elif borough in east_boroughs:
# East boroughs
x = center_x + np.random.uniform(1.0, 3.0)
y = center_y + np.random.normal(0, 1.5)
elif borough in west_boroughs:
# West boroughs
x = center_x - np.random.uniform(1.0, 3.0)
y = center_y + np.random.normal(0, 1.5)
elif borough in north_boroughs:
# North boroughs
x = center_x + np.random.normal(0, 1.5)
y = center_y + np.random.uniform(1.0, 3.0)
elif borough in south_boroughs:
# South boroughs
x = center_x + np.random.normal(0, 1.5)
y = center_y - np.random.uniform(1.0, 3.0)
else:
# Outer boroughs
angle = np.random.uniform(0, 2*np.pi)
distance = np.random.uniform(2.5, 4.0)
x = center_x + np.cos(angle) * distance
y = center_y + np.sin(angle) * distance
return x, y
# Create the location for each borough
for borough in borough_names:
category = "central" if borough in central_boroughs else "inner" if borough in inner_boroughs else "outer"
x, y = place_borough(borough, category)
borough_locations[borough] = (x, y)
# 3. Try to load socioeconomic data from the file if it exists
if os.path.exists(borough_data_path):
socioeconomic_data = pd.read_csv(borough_data_path)
else:
# If file doesn't exist, create synthetic data with the same approach as before
# to ensure visual consistency
socioeconomic_data = pd.DataFrame({'Borough': borough_names})
socioeconomic_data['x'] = socioeconomic_data['Borough'].map(lambda b: borough_locations[b][0])
socioeconomic_data['y'] = socioeconomic_data['Borough'].map(lambda b: borough_locations[b][1])
socioeconomic_data['category'] = socioeconomic_data['Borough'].map(
lambda b: "Central" if b in central_boroughs else "Inner" if b in inner_boroughs else "Outer"
)
# Create the realistic income gradient
socioeconomic_data['Average_Income'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.normal(70000, 5000) if x in central_boroughs
else np.random.normal(55000, 4000) if x in inner_boroughs
else np.random.normal(45000, 5000)
).round(0)
# Higher unemployment in the east
socioeconomic_data['Unemployment_Rate'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(7.5, 10.5) if x in east_boroughs
else np.random.uniform(4.0, 7.0)
).round(1)
# Higher education in the west and central
west_central = ['Westminster', 'Kensington and Chelsea', 'Richmond upon Thames', 'Wandsworth', 'Kingston upon Thames']
socioeconomic_data['Higher_Education_Rate'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(60, 75) if x in west_central
else np.random.uniform(40, 60) if x in inner_boroughs
else np.random.uniform(30, 45)
).round(1)
# 4. Try to load population point data from the file, or create the synthetic data
points_data_path = 'london_population_points.csv'
if os.path.exists(points_data_path):
points_df = pd.read_csv(points_data_path)
else:
# Create the synthetic population/household points
np.random.seed(42)
points_data = []
for borough in borough_names:
# Get borough location
borough_x, borough_y = borough_locations[borough]
# Determine the number of points per borough.
if borough in central_boroughs:
num_borough_points = int(np.random.normal(250, 50))
elif borough in inner_boroughs:
num_borough_points = int(np.random.normal(180, 30))
else:
num_borough_points = int(np.random.normal(130, 20))
num_borough_points = max(50, min(300, num_borough_points)) # Reasonable bounds
# Get the borough socioeconomic indicators
borough_data = socioeconomic_data[socioeconomic_data['Borough'] == borough].iloc[0]
avg_income = borough_data['Average_Income']
unemployment = borough_data['Unemployment_Rate']
education = borough_data['Higher_Education_Rate']
# Create the points with variation around borough averages
for _ in range(num_borough_points):
# Location with clustering around borough center
x = borough_x + np.random.normal(0, 0.4)
y = borough_y + np.random.normal(0, 0.4)
# Create the individual socioeconomic indicators with variation
income = max(15000, min(120000, np.random.normal(avg_income, avg_income * 0.15)))
person_unemployment = max(1, min(20, np.random.normal(unemployment, 2)))
person_education = max(5, min(95, np.random.normal(education, 10)))
# Transit attributes
transit_access = 0
points_data.append({
'x': x,
'y': y,
'borough': borough,
'category': borough_data['category'],
'income': income,
'unemployment': person_unemployment,
'education': person_education,
'transit_access': transit_access
})
# Create the DataFrame with all the points
points_df = pd.DataFrame(points_data)
# 5. Transit the lines data
transit_lines_path = 'london_transit_lines.csv'
# Use the consistent transit line data
transit_lines = [
# Line name, color, [(x1,y1), (x2,y2), ...] for route
('Central', '#E32017', [(-4, -0.2), (-2, -0.1), (0, 0), (2, 0.1), (4, 0.2)]),
('Northern', '#000000', [(0, -4), (0, -2), (0, 0), (0, 2), (0, 4)]),
('Jubilee', '#A0A5A9', [(-3, -3), (-1.5, -1.5), (0, 0), (1.5, 1.5), (3, 3)]),
('District', '#00782A', [(-3, 1), (-1.5, 0.5), (0, 0), (1.5, -0.5), (3, -1)]),
('Piccadilly', '#003688', [(-4, 1), (-2, 0.5), (0, 0), (2, -0.5), (4, -1)]),
('Victoria', '#0098D4', [(1, -3), (0.5, -1.5), (0, 0), (-0.5, 1.5), (-1, 3)]),
('Circle', '#FFD300', [
(-1.5, 0), (-1.3, 0.8), (-0.8, 1.3), (0, 1.5),
(0.8, 1.3), (1.3, 0.8), (1.5, 0), (1.3, -0.8),
(0.8, -1.3), (0, -1.5), (-0.8, -1.3), (-1.3, -0.8), (-1.5, 0)
])
]
# 6. Station data
stations_path = 'london_stations.csv'
if os.path.exists(stations_path):
stations_df = pd.read_csv(stations_path)
# Convert the string representation of lists to actual lists
stations_df['lines'] = stations_df['lines'].apply(eval)
else:
# Create the stations along transit lines
stations = []
line_geometries = {}
for line_name, line_color, line_points in transit_lines:
# Store the line geometry for later use
line_geometries[line_name] = line_points
# Create the stations along the line
for i, (x, y) in enumerate(line_points):
# Add some noise to station positions to make it look more realistic
if i > 0 and i < len(line_points) - 1:
x += np.random.normal(0, 0.05)
y += np.random.normal(0, 0.05)
# Determine if this is a major station
is_major = (i == 0 or i == len(line_points) - 1 or i == len(line_points) // 2)
is_central = (abs(x) < 1.5 and abs(y) < 1.5)
importance = 3 if is_major else 2 if is_central else 1
station_name = f"{line_name} Station {i+1}"
# Check if there's already a station here
existing_station = None
for s in stations:
if abs(s['x'] - x) < 0.1 and abs(s['y'] - y) < 0.1:
existing_station = s
break
if existing_station:
# This is an interchange
existing_station['lines'].append(line_name)
existing_station['importance'] = max(existing_station['importance'], importance + 1) # Interchanges are more important
else:
# Create the new station
stations.append({
'name': station_name,
'x': x,
'y': y,
'lines': [line_name],
'importance': importance
})
# Create the DataFrame for stations
stations_df = pd.DataFrame(stations)
# 7. Calculate the transit access for each population point if not already present
if 'transit_access' not in points_df.columns or points_df['transit_access'].sum() == 0:
# Points closer to stations, especially major stations/interchanges, have better access
for i, point in points_df.iterrows():
point_x, point_y = point['x'], point['y']
# Calculate the distances to all stations
distances = []
for _, station in stations_df.iterrows():
station_x, station_y = station['x'], station['y']
distance = np.sqrt((point_x - station_x)**2 + (point_y - station_y)**2)
# Weight by the station importance
weighted_distance = distance / (station['importance'] ** 0.5)
distances.append(weighted_distance)
# Calculate the transit access score
if distances:
# Take the 3 closest stations
closest_distances = sorted(distances)[:3]
# Transit score is inverse of the weighted distance to closest stations
min_dist = min(closest_distances)
transit_score = 100 * np.exp(-min_dist * 0.8)
# Add bonus for having multiple stations nearby
if len(closest_distances) >= 2:
transit_score += 10 * np.exp(-closest_distances[1] * 0.6)
if len(closest_distances) >= 3:
transit_score += 5 * np.exp(-closest_distances[2] * 0.4)
# Cap the score at 100
transit_score = min(100, transit_score)
else:
transit_score = 0
# Update the point's transit access
points_df.at[i, 'transit_access'] = transit_score
# Scale to 0-100 range
min_transit = points_df['transit_access'].min()
max_transit = points_df['transit_access'].max()
points_df['transit_access'] = 10 + 90 * (points_df['transit_access'] - min_transit) / (max_transit - min_transit)
# 8. Calculate the composite socioeconomic score if not already present
if 'socioeconomic_score' not in points_df.columns:
points_df['socioeconomic_score'] = (
(points_df['income'] / 1000) * 0.4 +
(100 - points_df['unemployment']) * 0.3 +
points_df['education'] * 0.3
)
# Normalize to 0-100 scale
min_score = points_df['socioeconomic_score'].min()
max_score = points_df['socioeconomic_score'].max()
points_df['socioeconomic_score'] = (points_df['socioeconomic_score'] - min_score) / (max_score - min_score) * 100
# 9. Calculate the borough-level statistics
borough_stats_path = 'london_borough_stats.csv'
if os.path.exists(borough_stats_path):
borough_stats_df = pd.read_csv(borough_stats_path)
else:
borough_stats = []
for borough in borough_names:
borough_points = points_df[points_df['borough'] == borough]
if len(borough_points) > 0:
stats = {
'Borough': borough,
'x': borough_locations[borough][0],
'y': borough_locations[borough][1],
'Population': len(borough_points),
'Avg_Transit_Access': borough_points['transit_access'].mean(),
'Avg_Socioeconomic_Score': borough_points['socioeconomic_score'].mean(),
'Avg_Income': borough_points['income'].mean(),
'Avg_Education': borough_points['education'].mean(),
'Avg_Unemployment': borough_points['unemployment'].mean()
}
borough_stats.append(stats)
borough_stats_df = pd.DataFrame(borough_stats)
# 10. Create the visualization with the London map background
map_image_path = 'london_map.png' # Path to London map image
# Create and save the visualization
fig, ax = create_intuitive_london_map(points_df, stations_df, borough_stats_df, transit_lines, map_image_path)
# Restore the stdout before showing the plot
sys.stdout = original_stdout
# Save the figure
output_filename = 'london_intuitive_dots_map.png'
plt.savefig(output_filename, dpi=300, bbox_inches='tight')
# Display the figure
plt.show()
print("\n--- WHAT THIS MAP SHOWS ---")
print("* Each dot represents a household/area in London and DOT SIZE shows transit accessibility:")
print(" Larger dots = Better access to public transportation")
print(" Smaller dots = Limited access to public transportation")
print("* DOT COLOR shows socioeconomic status:")
print(" Green dots = Higher socioeconomic status (better income, education, employment)")
print(" Yellow dots = Medium socioeconomic status")
print(" Red dots = Lower socioeconomic status (lower income, education, employment)")
print("* The map clearly shows how areas with better transit access (larger dots)")
print(" tend to have higher socioeconomic status (greener dots)")
# This would be helpful for reproducibility and faster loading next time
if not os.path.exists(borough_locations_path):
pd.DataFrame({'Borough': list(borough_locations.keys()),
'x': [v[0] for v in borough_locations.values()],
'y': [v[1] for v in borough_locations.values()]}).to_csv(borough_locations_path, index=False)
if not os.path.exists(borough_data_path):
socioeconomic_data.to_csv(borough_data_path, index=False)
if not os.path.exists(points_data_path):
points_df.to_csv(points_data_path, index=False)
if not os.path.exists(stations_path):
# Save with string representation of the lists
stations_df_save = stations_df.copy()
stations_df_save['lines'] = stations_df_save['lines'].apply(str)
stations_df_save.to_csv(stations_path, index=False)
if not os.path.exists(borough_stats_path):
borough_stats_df.to_csv(borough_stats_path, index=False)
except Exception as e:
sys.stdout = original_stdout
print(f"Error processing data: {e}")
# Create borough locations with the original logic
borough_locations = {}
# Function to place boroughs with some realistic geography
def place_borough(borough, category):
if borough in central_boroughs:
# Central boroughs clustered near the center
x = center_x + np.random.normal(0, 0.5)
y = center_y + np.random.normal(0, 0.5)
elif borough in east_boroughs:
# East boroughs
x = center_x + np.random.uniform(1.0, 3.0)
y = center_y + np.random.normal(0, 1.5)
elif borough in west_boroughs:
# West boroughs
x = center_x - np.random.uniform(1.0, 3.0)
y = center_y + np.random.normal(0, 1.5)
elif borough in north_boroughs:
# North boroughs
x = center_x + np.random.normal(0, 1.5)
y = center_y + np.random.uniform(1.0, 3.0)
elif borough in south_boroughs:
# South boroughs
x = center_x + np.random.normal(0, 1.5)
y = center_y - np.random.uniform(1.0, 3.0)
else:
# Outer boroughs
angle = np.random.uniform(0, 2*np.pi)
distance = np.random.uniform(2.5, 4.0)
x = center_x + np.cos(angle) * distance
y = center_y + np.sin(angle) * distance
return x, y
# Create the location for each borough
for borough in borough_names:
category = "central" if borough in central_boroughs else "inner" if borough in inner_boroughs else "outer"
x, y = place_borough(borough, category)
borough_locations[borough] = (x, y)
# Create synthetic socioeconomic data with the realistic patterns
socioeconomic_data = pd.DataFrame({'Borough': borough_names})
socioeconomic_data['x'] = socioeconomic_data['Borough'].map(lambda b: borough_locations[b][0])
socioeconomic_data['y'] = socioeconomic_data['Borough'].map(lambda b: borough_locations[b][1])
socioeconomic_data['category'] = socioeconomic_data['Borough'].map(
lambda b: "Central" if b in central_boroughs else "Inner" if b in inner_boroughs else "Outer"
)
# Create realistic income gradient
socioeconomic_data['Average_Income'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.normal(70000, 5000) if x in central_boroughs
else np.random.normal(55000, 4000) if x in inner_boroughs
else np.random.normal(45000, 5000)
).round(0)
# Higher unemployment in east
socioeconomic_data['Unemployment_Rate'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(7.5, 10.5) if x in east_boroughs
else np.random.uniform(4.0, 7.0)
).round(1)
# Higher education in west and central
west_central = ['Westminster', 'Kensington and Chelsea', 'Richmond upon Thames', 'Wandsworth', 'Kingston upon Thames']
socioeconomic_data['Higher_Education_Rate'] = socioeconomic_data['Borough'].apply(
lambda x: np.random.uniform(60, 75) if x in west_central
else np.random.uniform(40, 60) if x in inner_boroughs
else np.random.uniform(30, 45)
).round(1)
# Create synthetic population/household points
np.random.seed(42)
points_data = []
for borough in borough_names:
# Get borough location
borough_x, borough_y = borough_locations[borough]
# Determine the number of points per borough
if borough in central_boroughs:
num_borough_points = int(np.random.normal(250, 50))
elif borough in inner_boroughs:
num_borough_points = int(np.random.normal(180, 30))
else:
num_borough_points = int(np.random.normal(130, 20))
num_borough_points = max(50, min(300, num_borough_points)) # Reasonable bounds
# Get borough the socioeconomic indicators
borough_data = socioeconomic_data[socioeconomic_data['Borough'] == borough].iloc[0]
avg_income = borough_data['Average_Income']
unemployment = borough_data['Unemployment_Rate']
education = borough_data['Higher_Education_Rate']
# Create points with the variation around the borough averages
for _ in range(num_borough_points):
# Location with clustering around the borough center
x = borough_x + np.random.normal(0, 0.4)
y = borough_y + np.random.normal(0, 0.4)
# Create individual socioeconomic indicators with the variation
income = max(15000, min(120000, np.random.normal(avg_income, avg_income * 0.15)))
person_unemployment = max(1, min(20, np.random.normal(unemployment, 2)))
person_education = max(5, min(95, np.random.normal(education, 10)))
# Transit attributes
transit_access = 0
points_data.append({
'x': x,
'y': y,
'borough': borough,
'category': borough_data['category'],
'income': income,
'unemployment': person_unemployment,
'education': person_education,
'transit_access': transit_access
})
# Create DataFrame with all the points
points_df = pd.DataFrame(points_data)
# Transit lines the data
transit_lines = [
('Central', '#E32017', [(-4, -0.2), (-2, -0.1), (0, 0), (2, 0.1), (4, 0.2)]),
('Northern', '#000000', [(0, -4), (0, -2), (0, 0), (0, 2), (0, 4)]),
('Jubilee', '#A0A5A9', [(-3, -3), (-1.5, -1.5), (0, 0), (1.5, 1.5), (3, 3)]),
('District', '#00782A', [(-3, 1), (-1.5, 0.5), (0, 0), (1.5, -0.5), (3, -1)]),
('Piccadilly', '#003688', [(-4, 1), (-2, 0.5), (0, 0), (2, -0.5), (4, -1)]),
('Victoria', '#0098D4', [(1, -3), (0.5, -1.5), (0, 0), (-0.5, 1.5), (-1, 3)]),
('Circle', '#FFD300', [
(-1.5, 0), (-1.3, 0.8), (-0.8, 1.3), (0, 1.5),
(0.8, 1.3), (1.3, 0.8), (1.5, 0), (1.3, -0.8),
(0.8, -1.3), (0, -1.5), (-0.8, -1.3), (-1.3, -0.8), (-1.5, 0)
])
]
# Create the stations along transit lines
stations = []
line_geometries = {}
for line_name, line_color, line_points in transit_lines:
# Store line geometry for later use
line_geometries[line_name] = line_points
# Create the stations along the line
for i, (x, y) in enumerate(line_points):
# Add some noise to the station positions to make it look more realistic
if i > 0 and i < len(line_points) - 1:
x += np.random.normal(0, 0.05)
y += np.random.normal(0, 0.05)
# Determine if this is a major station
is_major = (i == 0 or i == len(line_points) - 1 or i == len(line_points) // 2)
is_central = (abs(x) < 1.5 and abs(y) < 1.5)
importance = 3 if is_major else 2 if is_central else 1
station_name = f"{line_name} Station {i+1}"
# Check if there's already a station here
existing_station = None
for s in stations:
if abs(s['x'] - x) < 0.1 and abs(s['y'] - y) < 0.1:
existing_station = s
break
if existing_station:
# This is an interchange
existing_station['lines'].append(line_name)
existing_station['importance'] = max(existing_station['importance'], importance + 1) # Interchanges are more important
else:
# Create new station
stations.append({
'name': station_name,
'x': x,
'y': y,
'lines': [line_name],
'importance': importance
})
# Create DataFrame for the stations
stations_df = pd.DataFrame(stations)
# Calculate transit access for each population point
for i, point in points_df.iterrows():
point_x, point_y = point['x'], point['y']
# Calculate the distances to all stations
distances = []
for _, station in stations_df.iterrows():
station_x, station_y = station['x'], station['y']
distance = np.sqrt((point_x - station_x)**2 + (point_y - station_y)**2)
# Weight by station importance
weighted_distance = distance / (station['importance'] ** 0.5)
distances.append(weighted_distance)
# Calculate the transit access score (closer = better)
if distances:
# Take the 3 closest stations
closest_distances = sorted(distances)[:3]
# Transit score is inverse of weighted distance to closest stations
min_dist = min(closest_distances)
transit_score = 100 * np.exp(-min_dist * 0.8)
# Add bonus for the having multiple stations nearby
if len(closest_distances) >= 2:
transit_score += 10 * np.exp(-closest_distances[1] * 0.6)
if len(closest_distances) >= 3:
transit_score += 5 * np.exp(-closest_distances[2] * 0.4)
# Cap the score at 100
transit_score = min(100, transit_score)
else:
transit_score = 0
# Update the point's transit access
points_df.at[i, 'transit_access'] = transit_score
# Adjust transit scores to create more variation
# Scale to 0-100 range
min_transit = points_df['transit_access'].min()
max_transit = points_df['transit_access'].max()
points_df['transit_access'] = 10 + 90 * (points_df['transit_access'] - min_transit) / (max_transit - min_transit)
# Calculate the composite socioeconomic score
points_df['socioeconomic_score'] = (
(points_df['income'] / 1000) * 0.4 +
(100 - points_df['unemployment']) * 0.3 +
points_df['education'] * 0.3
)
# Normalize to 0-100 scale
min_score = points_df['socioeconomic_score'].min()
max_score = points_df['socioeconomic_score'].max()
points_df['socioeconomic_score'] = (points_df['socioeconomic_score'] - min_score) / (max_score - min_score) * 100
# Calculate the borough-level statistics
borough_stats = []
for borough in borough_names:
borough_points = points_df[points_df['borough'] == borough]
if len(borough_points) > 0:
stats = {
'Borough': borough,
'x': borough_locations[borough][0],
'y': borough_locations[borough][1],
'Population': len(borough_points),
'Avg_Transit_Access': borough_points['transit_access'].mean(),
'Avg_Socioeconomic_Score': borough_points['socioeconomic_score'].mean(),
'Avg_Income': borough_points['income'].mean(),
'Avg_Education': borough_points['education'].mean(),
'Avg_Unemployment': borough_points['unemployment'].mean()
}
borough_stats.append(stats)
borough_stats_df = pd.DataFrame(borough_stats)
# Restore the stdout
sys.stdout = original_stdout
# Create the visualization with the London map background
map_image_path = 'london_map.png'
fig, ax = create_intuitive_london_map(points_df, stations_df, borough_stats_df, transit_lines, map_image_path)
# Save the figure
output_filename = 'london_intuitive_dots_map.png'
plt.savefig(output_filename, dpi=300, bbox_inches='tight')
# Show the figure
plt.show()
print("\n--- WHAT THIS MAP SHOWS ---")
print("- Each dot represents a household/area in London and DOT SIZE shows transit accessibility:")
print(" Larger dots = Better access to public transportation")
print(" Smaller dots = Limited access to public transportation")
print("- DOT COLOR shows socioeconomic status:")
print(" Green dots = Higher socioeconomic status (better income, education, employment)")
print(" Yellow dots = Medium socioeconomic status")
print(" Red dots = Lower socioeconomic status (lower income, education, employment)")
print("- The map clearly shows how areas with better transit access (larger dots)")
print(" tend to have higher socioeconomic status (greener dots)")
# Run the main function
if __name__ == "__main__":
main()
--- WHAT THIS MAP SHOWS --- * Each dot represents a household/area in London and DOT SIZE shows transit accessibility: Larger dots = Better access to public transportation Smaller dots = Limited access to public transportation * DOT COLOR shows socioeconomic status: Green dots = Higher socioeconomic status (better income, education, employment) Yellow dots = Medium socioeconomic status Red dots = Lower socioeconomic status (lower income, education, employment) * The map clearly shows how areas with better transit access (larger dots) tend to have higher socioeconomic status (greener dots)
This cell creates the primary visualization showing the relationship between transit access and socioeconomic factors in London. The code defines a function called create_intuitive_london_map that generates a comprehensive map integrating multiple data dimensions simultaneously.
The visualization employs an intuitive dual-encoding strategy where point color represents socioeconomic status (using a red-yellow-green spectrum where green indicates higher status) while point size represents transit accessibility (larger points indicating better access).
The map includes London's transit lines rendered in their authentic colors with proper labeling, borough boundaries with clear labels, and strategically positioned explanatory text boxes that guide interpretation. Particular attention is given to legend design, with separate sections explaining both the color and size encodings to ensure users can correctly interpret the patterns.
The function intelligently handles missing data by generating synthetic patterns that mirror real-world relationships when actual files aren't available, ensuring the visualization's educational value remains intact regardless of data availability.RetryClaude can make mistakes. Please double-check responses.
Property Value Premium Visualization¶
In [7]:
# Load the data files
print("Loading data files...")
try:
# Load London boroughs
london_boroughs = gpd.read_file('london_boroughs.geojson')
has_boroughs = True
except Exception as e:
print(f"Could not load boroughs: {e}")
has_boroughs = False
try:
# Load the stations
stations_df = pd.read_csv('Stations_20220221.csv')
# Create the geometry
geometry = [Point(x, y) for x, y in zip(stations_df['x'], stations_df['y'])]
stations_gdf = gpd.GeoDataFrame(stations_df, geometry=geometry, crs="EPSG:4326")
except Exception as e:
print(f"Error loading station data: {e}")
stations_gdf = None
try:
# Try to load the property data
property_data = pd.read_csv('london_property_data.csv')
except:
try:
property_data = pd.read_csv('london_property_data.csv')
except Exception as e:
print(f"Could not load property data: {e}")
# Create simplified sample
np.random.seed(42)
central_lat, central_lon = 51.5074, -0.1278
property_data = pd.DataFrame({
'Latitude': central_lat + np.random.normal(0, 0.05, 300),
'Longitude': central_lon + np.random.normal(0, 0.07, 300),
'Distance_Band': np.random.choice(['0-200m', '200-400m', '400-800m', '800-1500m', '>1500m'], 300),
'Station_Premium_Pct': np.random.uniform(-5, 25, 300)
})
# Create the basic distance bands if not present
if 'Distance_Band' not in property_data.columns:
property_data['Distance_Band'] = np.random.choice(
['0-200m', '200-400m', '400-800m', '800-1500m', '>1500m'],
len(property_data)
)
# Create the basic premium data if not present
if 'Station_Premium_Pct' not in property_data.columns:
property_data['Station_Premium_Pct'] = property_data['Distance_Band'].map({
'0-200m': np.random.uniform(15, 25),
'200-400m': np.random.uniform(10, 20),
'400-800m': np.random.uniform(5, 15),
'800-1500m': np.random.uniform(0, 10),
'>1500m': np.random.uniform(-5, 5)
})
# Function to create a simple map with dots
def create_simple_dot_map_with_table():
"""Create a simple map with colored dots and an information table"""
# Create a figure with a map and table
fig = plt.figure(figsize=(14, 12))
# Define the layout - map on top, table below
gs = plt.GridSpec(2, 1, height_ratios=[3, 1], hspace=0.1)
# Create the axes for map and table
ax_map = fig.add_subplot(gs[0])
ax_table = fig.add_subplot(gs[1])
# Create the GeoDataFrame for property data
lat_col = next((col for col in property_data.columns if col.lower() in ['latitude', 'lat', 'y']), None)
lon_col = next((col for col in property_data.columns if col.lower() in ['longitude', 'lon', 'lng', 'x']), None)
if lat_col and lon_col:
# Create the property GeoDataFrame
prop_geometry = [Point(x, y) for x, y in zip(property_data[lon_col], property_data[lat_col])]
property_gdf = gpd.GeoDataFrame(property_data, geometry=prop_geometry, crs="EPSG:4326")
else:
print("Error: Property data missing coordinate columns")
return
# Convert to the Web Mercator
property_3857 = property_gdf.to_crs(epsg=3857)
stations_3857 = stations_gdf.to_crs(epsg=3857) if stations_gdf is not None else None
boroughs_3857 = london_boroughs.to_crs(epsg=3857) if has_boroughs else None
# Plot the borough boundaries if available
if boroughs_3857 is not None:
boroughs_3857.boundary.plot(
ax=ax_map,
linewidth=0.7,
color='black',
alpha=0.5
)
# Plot the properties as colored dots
scatter = ax_map.scatter(
property_3857.geometry.x,
property_3857.geometry.y,
c=property_3857['Station_Premium_Pct'],
cmap='RdYlGn', # Red-Yellow-Green
alpha=0.7,
s=30,
vmin=-5,
vmax=25,
edgecolor='none'
)
# Plot the stations if available
if stations_3857 is not None:
ax_map.scatter(
stations_3857.geometry.x,
stations_3857.geometry.y,
color='white',
edgecolor='black',
s=50,
alpha=0.8,
zorder=5
)
# Add the basemap
try:
ctx.add_basemap(ax_map, source=ctx.providers.CartoDB.Positron)
except Exception as e:
print(f"Could not add basemap: {e}")
# Add the colorbar
cbar = plt.colorbar(scatter, ax=ax_map, orientation='horizontal', pad=0.01, shrink=0.5)
cbar.set_label('Price Premium Due to Station Proximity (%)')
# Set title and remove the axis
ax_map.set_title('Property Value Premium from Transit Proximity', fontsize=14)
ax_map.set_axis_off()
# ===== CREATE THE TABLE =====
# Calculate the average premium by the distance band
premium_by_band = property_data.groupby('Distance_Band')['Station_Premium_Pct'].agg(['mean', 'count']).reset_index()
# Sort the bands logically
band_order = {"0-200m": 0, "200-400m": 1, "400-800m": 2, "800-1500m": 3, ">1500m": 4}
premium_by_band['order'] = premium_by_band['Distance_Band'].map(band_order)
premium_by_band = premium_by_band.sort_values('order').drop('order', axis=1)
# Format the data for the table
premium_by_band['mean'] = premium_by_band['mean'].round(1).astype(str) + '%'
premium_by_band['count'] = premium_by_band['count'].astype(int).astype(str)
# Rename the columns
premium_by_band.columns = ['Distance to Station', 'Avg. Price Premium', 'Number of Properties']
# Create the table
ax_table.axis('tight')
ax_table.axis('off')
# Add the table
table = ax_table.table(
cellText=premium_by_band.values,
colLabels=premium_by_band.columns,
loc='center',
cellLoc='center'
)
# Style the table
table.auto_set_font_size(False)
table.set_fontsize(12)
table.scale(1.2, 1.5)
# Color the table cells based on premium
for i in range(len(premium_by_band)):
# Get premium value from the cell text
premium_text = premium_by_band.iloc[i, 1]
premium_value = float(premium_text.strip('%'))
# Calculate the color
if premium_value >= 15:
cell_color = (0.6, 0.9, 0.6) # Light green
elif premium_value >= 5:
cell_color = (0.9, 0.9, 0.6) # Light yellow
else:
cell_color = (0.9, 0.7, 0.7) # Light red
# Apply the color to the premium cell
table[(i+1, 1)].set_facecolor(cell_color)
# Add title to the table
ax_table.set_title('Transit Proximity Premium by Distance Band', fontsize=14)
# ===== ADD SIMPLE EXPLANATION =====
closest_premium = premium_by_band.iloc[0, 1]
fig.text(
0.5, 0.03,
f"Properties closest to transit stations (0-200m) command a premium of {closest_premium} over properties more than 1500m away.\nThis shows the economic value created by transit accessibility in London's property market.",
ha='center',
va='center',
fontsize=12,
bbox=dict(facecolor='white', alpha=0.8, boxstyle='round,pad=0.5', edgecolor='gray')
)
return fig
# Create and display the map
fig = create_simple_dot_map_with_table()
plt.show()
Loading data files...
This cell creates a dot map visualization examining the economic impact of transit proximity on London property values. Through a function called create_simple_dot_map_with_table, the code generates a dual-component visualization that combines spatial representation with tabular analysis. The upper portion displays a map where properties are represented as color-coded dots based on their price premium relative to transit station proximity, with transit stations and borough boundaries included for spatial context.
The lower portion features a data table that quantifies the average property price premiums across progressive distance bands from stations, with conditional formatting highlighting the premium gradient. The visualization employs a red-yellow-green color scheme to emphasize the economic value of transit accessibility, revealing a clear inverse relationship where property values systematically decrease as distance from stations increases.
This combined spatial-tabular approach effectively translates abstract transit accessibility concepts into concrete market valuations that stakeholders can readily understand and apply to policy or investment decisions.
Social Mobility Choropleth Map¶
In [9]:
# Set matplotlib params
plt.rcParams['figure.figsize'] = [15, 15]
plt.rcParams['figure.dpi'] = 100
# Load the London boroughs from GeoJSON file
london_boroughs = gpd.read_file('london_boroughs.geojson')
# Print the columns to confirm structure
print("Columns in london_boroughs:")
print(london_boroughs.columns.tolist())
# Function to generate synthetic social mobility and the transit data
def generate_analysis_data(boroughs_gdf):
"""
Generate simulated social mobility and transit accessibility data
for London boroughs
"""
# Create a dictionary to map boroughs to zone categories
# 1: Inner London, 2: Outer London but good connections, 3: Outer London limited connections
inner_boroughs = [
'Camden', 'City of London', 'Hackney', 'Hammersmith and Fulham',
'Islington', 'Kensington and Chelsea', 'Lambeth', 'Lewisham',
'Southwark', 'Tower Hamlets', 'Wandsworth', 'Westminster'
]
middle_boroughs = [
'Barnet', 'Brent', 'Ealing', 'Greenwich', 'Haringey',
'Merton', 'Newham', 'Waltham Forest', 'Richmond upon Thames'
]
# All other boroughs are considered outer
analysis_data = []
np.random.seed(42)
for _, borough in boroughs_gdf.iterrows():
# Get the borough name
borough_name = borough['name'] # Changed from 'NAME' to 'name'
# Determine zone category based on the name
if borough_name in inner_boroughs:
zone = 1
transit_idx = np.random.uniform(7.5, 9.8)
elif borough_name in middle_boroughs:
zone = 2
transit_idx = np.random.uniform(5.0, 7.8)
else:
zone = 3
transit_idx = np.random.uniform(3.0, 6.0)
# Add noise to social mobility based on the transit + some randomness
# Higher transit generally means higher social mobility with some variance
social_mobility = transit_idx * 0.8 + np.random.normal(0, 1.2)
# Bound between 0 and 10
social_mobility = max(0, min(10, social_mobility))
# Add more metrics for the analysis
higher_ed_rate = transit_idx * 5 + np.random.normal(0, 8) # percentage
higher_ed_rate = max(10, min(70, higher_ed_rate)) # bound between 10% and 70%
median_income = 25000 + (transit_idx * 5000) + np.random.normal(0, 8000)
analysis_data.append({
'name': borough_name, # Match the column name in london_boroughs
'Zone_Category': zone,
'Transit_Accessibility_Index': round(transit_idx, 2),
'Social_Mobility_Score': round(social_mobility, 2),
'Higher_Education_Rate': round(higher_ed_rate, 1),
'Median_Income': round(median_income, -2), # Round to nearest 100
})
return pd.DataFrame(analysis_data)
# Generate the analysis data
analysis_data = generate_analysis_data(london_boroughs)
# Function to create the social mobility map
def create_social_mobility_map(borough_data):
"""Create a map showing social mobility correlation with transit access"""
# Create the figure
fig, ax = plt.subplots(figsize=(15, 15))
# Make sure data is in the right CRS for the contextily
if borough_data.crs != "EPSG:3857":
try:
# Try to convert to Web Mercator for the basemap compatibility
borough_data = borough_data.to_crs(epsg=3857)
except Exception as e:
print(f"Warning: Could not convert CRS: {e}")
# Get the bounds from the data to focus on the map
greater_london_bounds = {
'x': [borough_data.total_bounds[0], borough_data.total_bounds[2]],
'y': [borough_data.total_bounds[1], borough_data.total_bounds[3]]
}
# Add a buffer to the bounds to make sure everything is visible
x_buffer = (greater_london_bounds['x'][1] - greater_london_bounds['x'][0]) * 0.1
y_buffer = (greater_london_bounds['y'][1] - greater_london_bounds['y'][0]) * 0.1
greater_london_bounds['x'][0] -= x_buffer
greater_london_bounds['x'][1] += x_buffer
greater_london_bounds['y'][0] -= y_buffer
greater_london_bounds['y'][1] += y_buffer
# Define a sequential colormap for the social mobility
cmap = plt.cm.RdYlBu
# Plot boroughs colored by the social mobility
if 'Social_Mobility_Score' in borough_data.columns:
plot_col = 'Social_Mobility_Score'
legend_label = 'Social Mobility Score'
else:
# Fallback if specific score not available
if 'Higher_Education_Rate' in borough_data.columns:
plot_col = 'Higher_Education_Rate'
legend_label = 'Higher Education Rate (%)'
else:
# Just plot the boroughs without the color
plot_col = None
legend_label = None
if plot_col:
# Plot boroughs with choropleth coloring
borough_data.plot(
column=plot_col,
cmap=cmap,
linewidth=0.8,
edgecolor='black',
alpha=0.7,
ax=ax,
legend=True,
legend_kwds={
'label': legend_label,
'orientation': 'horizontal',
'shrink': 0.6,
'pad': 0.05
}
)
else:
# Just plot outlines if no data is available
borough_data.boundary.plot(
linewidth=1,
color='black',
ax=ax
)
# Add scatter plot showing relationship between transit and the social mobility
if all(col in borough_data.columns for col in ['Transit_Accessibility_Index', 'Social_Mobility_Score']):
# Create very small inset axis for the scatterplot
inset_ax = fig.add_axes([0.82, 0.08, 0.17, 0.17]) # [left, bottom, width, height]
# Create scatter plot with very small points
scatter = inset_ax.scatter(
borough_data['Transit_Accessibility_Index'],
borough_data['Social_Mobility_Score'],
c=borough_data['Social_Mobility_Score'],
cmap=cmap,
alpha=0.8,
s=30, # Small points
edgecolor='black',
linewidth=0.5
)
# Add labels to only two key boroughs with the small font
key_boroughs = ['Westminster', 'Newham']
# Filter to ensure we only try to label boroughs that exist in our data
key_boroughs = [b for b in key_boroughs if b in borough_data['name'].values]
for idx, row in borough_data.iterrows():
# Only label key boroughs to avoid the clutter
if row['name'] in key_boroughs:
inset_ax.annotate(
row['name'].split()[0],
xy=(row['Transit_Accessibility_Index'], row['Social_Mobility_Score']),
xytext=(2, 0),
textcoords='offset points',
fontsize=5,
color='black'
)
# Add the trend line
x = borough_data['Transit_Accessibility_Index']
y = borough_data['Social_Mobility_Score']
z = np.polyfit(x, y, 1)
p = np.poly1d(z)
inset_ax.plot(
x, p(x),
linestyle='--',
color='black',
alpha=0.7,
linewidth=0.7
)
# Calculate the correlation coefficient
corr = x.corr(y)
# Add correlation to the plot with the smaller font
inset_ax.text(
0.05, 0.95,
f'r = {corr:.2f}',
transform=inset_ax.transAxes,
fontsize=5,
verticalalignment='top',
bbox=dict(boxstyle='round', facecolor='white', alpha=0.7, pad=0.2)
)
# Format inset with the smaller fonts
inset_ax.set_title('Transit vs Mobility', fontsize=6)
inset_ax.set_xlabel('Transit Access', fontsize=5)
inset_ax.set_ylabel('Social Mobility', fontsize=5)
inset_ax.tick_params(axis='both', labelsize=4)
# Fewer ticks for the cleaner look
inset_ax.xaxis.set_major_locator(plt.MaxNLocator(3))
inset_ax.yaxis.set_major_locator(plt.MaxNLocator(3))
inset_ax.grid(False)
# Add border to the inset
for spine in inset_ax.spines.values():
spine.set_edgecolor('black')
spine.set_linewidth(0.5)
# Add regression details if we have the necessary data
if all(col in borough_data.columns for col in ['Transit_Accessibility_Index', 'Social_Mobility_Score']):
# Run a simple regression
X = sm.add_constant(borough_data['Transit_Accessibility_Index'])
model = sm.OLS(borough_data['Social_Mobility_Score'], X).fit()
# Create the results inset
results_ax = fig.add_axes([0.1, 0.15, 0.25, 0.2])
results_ax.axis('off')
# Format the regression results
results_text = "Regression Results:\n"
results_text += f"R-squared: {model.rsquared:.3f}\n"
results_text += f"Coefficient: {model.params[1]:.3f}\n"
results_text += f"p-value: {model.pvalues[1]:.3f}\n\n"
# Statistical interpretation
if model.pvalues[1] < 0.05:
results_text += "Finding: Transit accessibility has a statistically\n"
results_text += "significant effect on social mobility measures."
else:
results_text += "Finding: No statistically significant relationship\n"
results_text += "detected between transit access and social mobility."
# Add text to inset
results_ax.text(
0, 1,
results_text,
fontsize=9,
va='top',
bbox=dict(boxstyle='round', facecolor='white', alpha=0.7, edgecolor='black')
)
# Set map bounds and add basemap
ax.set_xlim(greater_london_bounds['x'])
ax.set_ylim(greater_london_bounds['y'])
try:
ctx.add_basemap(ax, source=ctx.providers.CartoDB.Positron)
except Exception as e:
print(f"Warning: Could not add basemap: {e}")
print("This is not critical - the map will still be created without the basemap layer.")
# Add borough labels at centroids
for idx, row in borough_data.iterrows():
if row.geometry and hasattr(row.geometry, 'centroid'):
# Get the borough name
borough_name = row['name']
# Only add label if the borough is big enough
if row.geometry.area > 1e7:
try:
# Simple borough labels without special highlighting
ax.annotate(
borough_name,
xy=(row.geometry.centroid.x, row.geometry.centroid.y),
ha='center',
fontsize=8,
color='black'
)
except Exception as e:
print(f"Warning: Couldn't add label for {borough_name}: {e}")
# Customize the plot
ax.set_title('Transit Accessibility and Social Mobility in London', fontsize=16, pad=20)
# Add explanatory text
if all(col in borough_data.columns for col in ['Transit_Accessibility_Index', 'Social_Mobility_Score']):
# Calculate the correlation
corr = borough_data['Transit_Accessibility_Index'].corr(borough_data['Social_Mobility_Score'])
ax.text(
0.01, 0.01,
f'Transit accessibility shows a {abs(corr):.2f} correlation with social mobility metrics.\nThis suggests that transit investment may have implications for social equity and opportunity.',
transform=ax.transAxes,
fontsize=12,
bbox=dict(facecolor='white', alpha=0.7, boxstyle="round,pad=0.5", edgecolor='black')
)
else:
ax.text(
0.01, 0.01,
'This map explores the relationship between transit access and social mobility.\nAreas with better transit access often show higher indicators of social advancement.',
transform=ax.transAxes,
fontsize=12,
bbox=dict(facecolor='white', alpha=0.7, boxstyle="round,pad=0.5", edgecolor='black')
)
ax.set_axis_off()
plt.tight_layout()
# Save the figure
plt.savefig('map3_social_mobility.png', dpi=300, bbox_inches='tight')
return fig, ax
# Function to create a table of borough data
def create_borough_table(borough_data):
"""Create a formatted table of borough data"""
# Create a copy of the data without geometry for table display
if isinstance(borough_data, gpd.GeoDataFrame):
table_data = borough_data.drop(columns=['geometry']).copy()
else:
table_data = borough_data.copy()
# Select and rename columns for display
columns_to_show = ['name', 'Zone_Category', 'Transit_Accessibility_Index', 'Social_Mobility_Score']
# Check if columns exist or not.
columns_to_show = [col for col in columns_to_show if col in table_data.columns]
if len(columns_to_show) == 0:
print("No data columns found for table.")
return None
# Get the subset of data
table_subset = table_data[columns_to_show].copy()
# Rename columns for the display
column_names = {
'name': 'Borough Name',
'Zone_Category': 'Zone Category',
'Transit_Accessibility_Index': 'Transit Access Score',
'Social_Mobility_Score': 'Social Mobility Score'
}
table_subset = table_subset.rename(columns={col: column_names.get(col, col) for col in table_subset.columns})
# Sort by social mobility score if available
if 'Social Mobility Score' in table_subset.columns:
table_subset = table_subset.sort_values('Social Mobility Score', ascending=False)
# Format the numeric columns
for col in table_subset.columns:
if col in ['Transit Access Score', 'Social Mobility Score']:
table_subset[col] = table_subset[col].apply(lambda x: f"{x:.2f}" if pd.notnull(x) else "")
# Create a figure and axis for the table
fig, ax = plt.subplots(figsize=(10, 12))
ax.axis('tight')
ax.axis('off')
# Create the table
table = ax.table(
cellText=table_subset.values,
colLabels=table_subset.columns,
loc='center',
cellLoc='center',
colColours=['#e6f3ff'] * len(table_subset.columns),
cellColours=[['#f5f5f5' if i % 2 == 0 else 'white' for _ in range(len(table_subset.columns))]
for i in range(len(table_subset))]
)
# Style the table
table.auto_set_font_size(False)
table.set_fontsize(10)
table.scale(1.2, 1.5)
# Add the title
plt.title('London Boroughs: Transit Accessibility and Social Mobility Data',
fontsize=16, pad=20)
plt.tight_layout()
# Save the table as the separate file
plt.savefig('borough_data_table.png', dpi=300, bbox_inches='tight')
return fig, ax, table_subset
# Use 'name' instead of 'Borough' for the merge
merged_data = london_boroughs.merge(analysis_data, on='name', how='left')
# Check if we have successfully merged the data
print(f"Successfully merged data for {merged_data['Transit_Accessibility_Index'].notna().sum()} out of {len(merged_data)} boroughs")
# Create and display the map
fig3, ax3 = create_social_mobility_map(merged_data)
plt.show()
# Create and display the borough data table
fig_table, ax_table, table_data = create_borough_table(merged_data)
plt.show()
Columns in london_boroughs: ['name', 'color', 'geometry'] Successfully merged data for 33 out of 33 boroughs
This cell creates a choropleth map with integrated statistical analysis to examine the relationship between transit accessibility and social mobility across London boroughs. The code generates a multifaceted visualization through two main functions: one that produces a color-coded borough-level map with an advanced analytical overlay, and another that creates a complementary data table.
The choropleth map uses a carefully selected color palette to represent social mobility scores, while an inset scatter plot provides direct visual evidence of the correlation between transit access and mobility outcomes. Statistical rigor is added through regression analysis components that display R-squared values, coefficients, and p-values, allowing users to assess both the strength and significance of the relationship.
Borough labels are selectively applied to maintain readability, and explanatory text is strategically positioned to guide interpretation. This comprehensive approach bridges descriptive spatial patterns with inferential statistics, effectively communicating both the geographic distribution of social mobility and its quantitative relationship with transit infrastructure at the borough level.vel.
DASHBOARD¶
In [79]:
# Configure Seaborn theme for better-looking plots
sns.set_theme(style="whitegrid")
sns.set_context("notebook", font_scale=1.2)
# Suppress warnings
warnings.filterwarnings('ignore')
# Initialize Panel extensions
pn.extension(sizing_mode="stretch_width")
# ==========================================================
# 1. DATA LOADING AND THE PREPARATION
# ==========================================================
print("Loading data from files...")
# Load the stations data
try:
stations_data = pd.read_csv('Stations_20220221.csv')
print(f"Loaded {len(stations_data)} transit stations")
# Create the GeoDataFrame for stations
stations_gdf = gpd.GeoDataFrame(
stations_data,
geometry=[Point(x, y) for x, y in zip(stations_data['x'], stations_data['y'])],
crs="EPSG:4326"
)
except Exception as e:
# print(f"Error loading stations data: {e}")
# Generate the synthetic stations if file not found
# print("Creating synthetic station data...")
n_stations = 300
stations_data = pd.DataFrame({
'NLC': range(1, n_stations+1),
'NAME': [f"Station {i}" for i in range(1, n_stations+1)],
'EASTING': np.random.uniform(500000, 560000, n_stations),
'NORTHING': np.random.uniform(150000, 200000, n_stations),
'LINES': [f"Line {np.random.choice(['A', 'B', 'C', 'D', 'E', 'F'])}" for _ in range(n_stations)],
'Zone': np.random.choice(['1', '2', '3', '4', '5', '6'], n_stations),
'x': np.random.uniform(-0.5, 0.2, n_stations),
'y': np.random.uniform(51.3, 51.7, n_stations)
})
# Create the GeoDataFrame for stations
stations_gdf = gpd.GeoDataFrame(
stations_data,
geometry=[Point(x, y) for x, y in zip(stations_data['x'], stations_data['y'])],
crs="EPSG:4326"
)
# Load the borough data
try:
# Try to load from the shapefile
london_boroughs = gpd.read_file('London_Borough_Excluding_MHW.shp')
# print(f"Loaded {len(london_boroughs)} London boroughs from shapefile")
except Exception as e:
try:
# Try to load from the geojson
london_boroughs = gpd.read_file('london_boroughs.geojson')
# print(f"Loaded {len(london_boroughs)} London boroughs from geojson")
except Exception as e:
# print(f"Error loading borough data: {e}")
# Create the synthetic borough data if files are not found
# print("Creating synthetic borough data...")
borough_names = [
'Camden', 'Greenwich', 'Hackney', 'Hammersmith and Fulham', 'Islington',
'Kensington and Chelsea', 'Lambeth', 'Lewisham', 'Southwark', 'Tower Hamlets',
'Wandsworth', 'Westminster', 'Barking and Dagenham', 'Barnet', 'Bexley',
'Brent', 'Bromley', 'Croydon', 'Ealing', 'Enfield', 'Haringey', 'Harrow',
'Havering', 'Hillingdon', 'Hounslow', 'Kingston upon Thames', 'Merton',
'Newham', 'Redbridge', 'Richmond upon Thames', 'Sutton', 'Waltham Forest'
]
# Create the random polygons for each borough
geometries = []
for i, name in enumerate(borough_names):
# Generate the polygon vertices in a circular pattern
center_x = -0.1 + (i % 6) * 0.12
center_y = 51.4 + (i // 6) * 0.1
# Create more realistic borough shape
n_points = np.random.randint(6, 12)
angles = np.sort(np.random.uniform(0, 2*np.pi, n_points))
distances = np.random.uniform(0.02, 0.04, n_points)
coords = []
for angle, distance in zip(angles, distances):
x = center_x + distance * np.cos(angle)
y = center_y + distance * np.sin(angle)
coords.append((x, y))
# Close the polygon
coords.append(coords[0])
geometries.append(Polygon(coords))
# Create the GeoDataFrame
london_boroughs = gpd.GeoDataFrame(
{'name': borough_names, 'geometry': geometries},
crs="EPSG:4326"
)
# Load the socioeconomic data by the borough
try:
socioeconomic_data = pd.read_csv('london_boroughs.csv')
# print(f"Loaded socioeconomic data for {len(socioeconomic_data)} boroughs")
# Rename columns if it's needed
if 'Borough' not in socioeconomic_data.columns:
if 'NAME' in socioeconomic_data.columns:
socioeconomic_data = socioeconomic_data.rename(columns={'NAME': 'Borough'})
else:
# Try to find a borough with the name column
potential_columns = ['Area', 'Area_name', 'LA_name', 'LAD', 'Local Authority', 'name']
for col in potential_columns:
if col in socioeconomic_data.columns:
socioeconomic_data = socioeconomic_data.rename(columns={col: 'Borough'})
break
# Ensure the borough names match
if 'name' in london_boroughs.columns and 'Borough' in socioeconomic_data.columns:
# Create a mapping from borough_name to socioeconomic data
socio_dict = socioeconomic_data.set_index('Borough').to_dict('index')
# Add the socioeconomic data to the boroughs
for idx, row in london_boroughs.iterrows():
borough_name = row['name']
if borough_name in socio_dict:
for key, value in socio_dict[borough_name].items():
london_boroughs.at[idx, key] = value
except Exception as e:
#print(f"Error loading socioeconomic data: {e}")
#print("Creating synthetic socioeconomic data...")
# Ensure the london_boroughs has a 'name' column
if 'name' not in london_boroughs.columns:
if 'NAME' in london_boroughs.columns:
london_boroughs = london_boroughs.rename(columns={'NAME': 'name'})
else:
london_boroughs['name'] = [f'Borough {i+1}' for i in range(len(london_boroughs))]
# Define the borough categories for synthetic data
borough_names = london_boroughs['name'].tolist()
central_west = ['Westminster', 'Kensington and Chelsea', 'Camden', 'Hammersmith and Fulham', 'Islington']
high_unemployment = ['Barking and Dagenham', 'Newham', 'Tower Hamlets', 'Hackney']
high_education = ['Richmond upon Thames', 'Kingston upon Thames', 'Westminster', 'Wandsworth']
expensive_areas = ['Westminster', 'Kensington and Chelsea', 'Camden', 'Hammersmith and Fulham']
mid_price_areas = ['Richmond upon Thames', 'Wandsworth', 'Islington', 'Hackney']
deprived_areas = ['Barking and Dagenham', 'Hackney', 'Newham', 'Tower Hamlets']
less_deprived = ['Richmond upon Thames', 'Kingston upon Thames', 'Sutton', 'Bromley']
high_employment = ['Westminster', 'Camden', 'Islington', 'Tower Hamlets', 'Southwark']
# Create the synthetic data
np.random.seed(42)
london_boroughs['Average_Income'] = london_boroughs['name'].apply(
lambda x: np.random.normal(60000, 5000) if x in central_west else np.random.normal(45000, 8000)
).round(0)
london_boroughs['Unemployment_Rate'] = london_boroughs['name'].apply(
lambda x: np.random.uniform(7.5, 10.5) if x in high_unemployment else np.random.uniform(4.0, 7.0)
).round(1)
london_boroughs['Higher_Education_Rate'] = london_boroughs['name'].apply(
lambda x: np.random.uniform(50, 65) if x in high_education else np.random.uniform(30, 50)
).round(1)
london_boroughs['Average_House_Price'] = london_boroughs['name'].apply(
lambda x: np.random.normal(1200000, 200000) if x in expensive_areas
else np.random.normal(700000, 100000) if x in mid_price_areas
else np.random.normal(450000, 80000)
).round(-3)
london_boroughs['Deprivation_Score'] = london_boroughs['name'].apply(
lambda x: np.random.uniform(30, 40) if x in deprived_areas
else np.random.uniform(10, 20) if x in less_deprived
else np.random.uniform(20, 30)
).round(1)
london_boroughs['Employment_Density'] = london_boroughs['name'].apply(
lambda x: np.random.uniform(80, 120) if x in high_employment else np.random.uniform(20, 50)
).round(1)
# Try to load the property data
try:
property_data = pd.read_csv('property_data.csv')
#print(f"Loaded {len(property_data)} property transactions")
# Debug the output
#print("Property data columns:", property_data.columns.tolist())
# Check the required columns
required_columns = ['Price', 'Distance_To_Station', 'Distance_Band', 'Property_Type']
missing_columns = [col for col in required_columns if col not in property_data.columns]
if missing_columns:
#print(f"WARNING: Missing required columns: {missing_columns}")
#print("Creating synthetic property data because of missing columns...")
raise Exception("Missing required columns")
# Print the data information
if 'Distance_Band' in property_data.columns:
print("Distance bands:", property_data['Distance_Band'].unique())
if 'Price' in property_data.columns:
print("Average price:", property_data['Price'].mean())
# If the property data contains geometry, convert to GeoDataFrame
if 'Latitude' in property_data.columns and 'Longitude' in property_data.columns:
try:
property_gdf = gpd.GeoDataFrame(
property_data,
geometry=[Point(x, y) for x, y in zip(property_data['Longitude'], property_data['Latitude'])],
crs="EPSG:4326"
)
except:
# If creating GeoDataFrame fails, just use the pandas DataFrame
print("Unable to create GeoDataFrame from property data, using pandas DataFrame")
property_gdf = property_data
else:
property_gdf = property_data
except Exception as e:
#print(f"Error loading property data: {e}")
#print("Creating synthetic property data...")
# Create the synthetic property data around the stations
properties = []
# Generate the properties around each station
for idx, station in stations_gdf.iterrows():
# Number of properties to generate around this station
n_properties = np.random.randint(3, 10)
# Station coordinates
station_x, station_y = station.geometry.x, station.geometry.y
# Get the zone
zone = station.get('Zone', '3') # Default to zone 3 if not specified
if isinstance(zone, str) and ',' in zone:
zone = zone.split(',')[0] # Take first zone for multi-zone stations
try:
zone_num = float(zone)
except:
zone_num = 3 # Default
# Base property price affected by the zone
base_price = max(100000, 1000000 - (zone_num * 120000))
# Generate the properties at different distances from the station
for _ in range(n_properties):
# Random distance from station (0-800m)
distance = np.random.uniform(0, 800)
# Create thedistance band
if distance < 200:
distance_band = '0-200m'
elif distance < 400:
distance_band = '200-400m'
elif distance < 600:
distance_band = '400-600m'
elif distance < 800:
distance_band = '600-800m'
else:
distance_band = '800m+'
# Random direction
angle = np.random.uniform(0, 2*np.pi)
# Calculate new position
prop_x = station_x + (distance/100000) * np.cos(angle)
prop_y = station_y + (distance/100000) * np.sin(angle)
# Calculate the price (closer to station = higher price, with some randomness)
price_factor = max(0.7, 1 - (distance / 1000))
price = base_price * price_factor * np.random.uniform(0.85, 1.15)
# Calculate the price premium percentage
premium_pct = max(-5, min(25, 25 * (1 - distance/1000) + np.random.normal(0, 3)))
# Property attributes
bedrooms = np.random.choice([1, 2, 2, 3, 3, 4])
property_type = np.random.choice(['Flat', 'Flat', 'Flat', 'House', 'House'])
properties.append({
'Latitude': prop_y,
'Longitude': prop_x,
'Price': round(price, -3), # Round to nearest thousand
'Bedrooms': bedrooms,
'Property_Type': property_type,
'Distance_To_Station': round(distance, 1),
'Distance_Band': distance_band,
'Station_Premium_Pct': round(premium_pct, 1),
'Nearest_Station': station['NAME'],
'Station_Zone': zone
})
property_data = pd.DataFrame(properties)
# Also create the GeoDataFrame version
property_gdf = gpd.GeoDataFrame(
property_data,
geometry=[Point(x, y) for x, y in zip(property_data['Longitude'], property_data['Latitude'])],
crs="EPSG:4326"
)
# Count transit stations per borough through the spatial join
try:
# Ensure both GeoDataFrames have the same CRS
if stations_gdf.crs != london_boroughs.crs:
stations_gdf = stations_gdf.to_crs(london_boroughs.crs)
# Spatial join to count stations as per borough
stations_with_borough = gpd.sjoin(
stations_gdf,
london_boroughs,
how="left",
predicate='within'
).fillna('Unknown')
# Count the stations per borough
if 'name' in stations_with_borough.columns:
stations_per_borough = stations_with_borough.groupby('name')['NLC'].count().reset_index()
stations_per_borough.columns = ['name', 'Station_Count']
elif 'NAME' in stations_with_borough.columns:
stations_per_borough = stations_with_borough.groupby('NAME')['NLC'].count().reset_index()
stations_per_borough.columns = ['name', 'Station_Count']
else:
stations_per_borough = stations_with_borough.groupby('index_right')['NLC'].count().reset_index()
stations_per_borough.columns = ['name', 'Station_Count']
# Add station counts to the borough data
london_boroughs = london_boroughs.merge(stations_per_borough, on='name', how='left').fillna(0)
# Calculate station density
london_boroughs['area_km2'] = london_boroughs.geometry.area * 111**2 # Rough conversion to km²
london_boroughs['Station_Density'] = london_boroughs['Station_Count'] / london_boroughs['area_km2']
except Exception as e:
print(f"Error in spatial join: {e}")
print("Creating synthetic station counts...")
# Generate random station counts
london_boroughs['Station_Count'] = np.random.randint(5, 30, size=len(london_boroughs))
london_boroughs['Station_Density'] = london_boroughs['Station_Count'] / 10
# Add Zone Categories to the boroughs
central_boroughs = ['Westminster', 'City of London', 'Camden', 'Islington', 'Kensington and Chelsea']
inner_boroughs = [
'Hackney', 'Hammersmith and Fulham', 'Lambeth', 'Lewisham',
'Southwark', 'Tower Hamlets', 'Wandsworth', 'Greenwich'
]
london_boroughs['Zone_Category'] = london_boroughs['name'].apply(
lambda x: 1 if x in central_boroughs else 2 if x in inner_boroughs else 3
)
# Calculate the Transit Accessibility Index
if 'Station_Count' in london_boroughs.columns and 'Station_Density' in london_boroughs.columns:
# Normalize and combine the station count and density
scaler = StandardScaler()
if len(london_boroughs) > 1: # Need at least 2 samples for StandardScaler
normalized_counts = scaler.fit_transform(london_boroughs[['Station_Count', 'Station_Density']])
london_boroughs['Transit_Accessibility_Index'] = (normalized_counts[:, 0] * 0.4 + normalized_counts[:, 1] * 0.6) * 2 + 5
else:
# Simple scaling for single borough case
london_boroughs['Transit_Accessibility_Index'] = 5 # Default value
# Ensure values are in a reasonable range (1-10)
min_val = london_boroughs['Transit_Accessibility_Index'].min()
max_val = london_boroughs['Transit_Accessibility_Index'].max()
if min_val != max_val: # Avoid division by zero
london_boroughs['Transit_Accessibility_Index'] = 1 + 9 * (london_boroughs['Transit_Accessibility_Index'] - min_val) / (max_val - min_val)
london_boroughs['Transit_Accessibility_Index'] = london_boroughs['Transit_Accessibility_Index'].round(2)
# Create the synthetic Social Mobility Score based on transit access
if 'Transit_Accessibility_Index' in london_boroughs.columns:
london_boroughs['Social_Mobility_Score'] = (
london_boroughs['Transit_Accessibility_Index'] * 0.7 +
np.random.normal(0, 1, size=len(london_boroughs))
).clip(1, 10).round(2)
# Calculate the correlation between transit access and socioeconomic variables
correlation_data = {}
if 'Transit_Accessibility_Index' in london_boroughs.columns:
for col in ['Social_Mobility_Score', 'Average_Income', 'Higher_Education_Rate', 'Unemployment_Rate', 'Deprivation_Score']:
if col in london_boroughs.columns:
correlation_data[col] = round(london_boroughs['Transit_Accessibility_Index'].corr(london_boroughs[col]), 3)
# Add a formatted column for the display in tables and the charts
if 'Average_Income' in london_boroughs.columns:
london_boroughs['Average_Income_Formatted'] = london_boroughs['Average_Income'].apply(lambda x: f"£{int(x):,}")
if 'Average_House_Price' in london_boroughs.columns:
london_boroughs['Average_House_Price_Formatted'] = london_boroughs['Average_House_Price'].apply(lambda x: f"£{int(x):,}")
print("Data preparation complete.")
# ==========================================================
# 2. VISUALIZATION FUNCTIONS
# ==========================================================
# Alternative chart creation using Matplotlib with the modern styling
def create_alt_scatter_chart(df, x_col, y_col, color_col=None, title="Scatter Plot"):
"""Create a modern-styled matplotlib scatter plot"""
# Set the modern style
plt.style.use('seaborn-v0_8-whitegrid')
fig, ax = plt.subplots(figsize=(10, 6), dpi=100)
fig.patch.set_facecolor('#F8F9FA')
ax.set_facecolor('#F8F9FA')
# Define a modern color palette
modern_palette = plt.cm.Set2.colors
if color_col and color_col in df.columns:
if pd.api.types.is_numeric_dtype(df[color_col]):
scatter = ax.scatter(
df[x_col],
df[y_col],
c=df[color_col],
cmap='viridis',
alpha=0.8,
s=100,
edgecolor='white',
linewidth=0.5
)
# Add the colorbar with modern styling
cbar = plt.colorbar(scatter, ax=ax)
cbar.ax.set_ylabel(color_col, fontsize=12)
cbar.outline.set_visible(False)
else:
# For categorical data, use categorical colors
categories = df[color_col].astype('category').cat.categories
category_colors = {
category: modern_palette[i % len(modern_palette)] for i, category in enumerate(categories)
}
# Plot each category
for category, group in df.groupby(color_col):
ax.scatter(
group[x_col],
group[y_col],
label=category,
color=category_colors.get(category, 'gray'),
alpha=0.8,
s=100,
edgecolor='white',
linewidth=0.5
)
# Add legend with the modern styling
legend = ax.legend(title=color_col, frameon=True, facecolor='white', edgecolor='none',
title_fontsize=12, fontsize=10, markerscale=0.8)
legend.get_frame().set_boxstyle('round,pad=0.5')
legend.get_frame().set_linewidth(0)
else:
# Single color scatter plot with a modern blue color
ax.scatter(
df[x_col],
df[y_col],
color='#1E88E5',
alpha=0.8,
s=100,
edgecolor='white',
linewidth=0.5
)
# Add regression line with the modern styling
if len(df) > 1: # Need at least 2 points for regression
try:
x = df[x_col]
y = df[y_col]
m, b = np.polyfit(x, y, 1)
# Plot the regression line
x_line = np.linspace(x.min(), x.max(), 100)
y_line = m * x_line + b
ax.plot(x_line, y_line, color='#E53935', linestyle='-',
linewidth=2.5, alpha=0.7, zorder=1)
# Add the correlation coefficient
corr = round(x.corr(y), 3)
ax.text(
0.05, 0.95,
f'Correlation: {corr}',
transform=ax.transAxes,
fontsize=12,
verticalalignment='top',
bbox=dict(
boxstyle='round,pad=0.5',
facecolor='white',
alpha=0.8,
edgecolor='none'
)
)
except Exception as e:
print(f"Error adding regression line: {e}")
# Add labels and title with the modern styling
ax.set_xlabel(x_col, fontsize=14, color='#333333')
ax.set_ylabel(y_col, fontsize=14, color='#333333')
ax.set_title(title, fontsize=16, fontweight='bold', color='#212121', pad=20)
# Style the grid
ax.grid(True, linestyle='--', alpha=0.3, color='#9E9E9E')
# Style the spines
for spine in ax.spines.values():
spine.set_visible(False)
# Style the ticks
ax.tick_params(axis='both', which='major', labelsize=11, colors='#555555')
plt.tight_layout()
# Convert plot to the image
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
# Return as HTML image
return pn.pane.HTML(f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);"/>')
def create_alt_bar_chart(df, x_col, y_col, title="Bar Chart", color_col=None):
"""Create a modern-styled matplotlib bar chart"""
# Set the modern style
plt.style.use('seaborn-v0_8-whitegrid')
fig, ax = plt.subplots(figsize=(12, 6), dpi=100)
fig.patch.set_facecolor('#F8F9FA')
ax.set_facecolor('#F8F9FA')
# Convert x column to string for categorical display
x_values = df[x_col].astype(str)
y_values = df[y_col]
# Color based on value or category
if color_col and color_col in df.columns:
colors = df[color_col]
norm = plt.Normalize(colors.min(), colors.max())
cmap = plt.cm.viridis
bar_colors = cmap(norm(colors))
elif isinstance(y_values, (pd.Series, np.ndarray)) and len(y_values) > 0:
# Color bars based on their height
norm = plt.Normalize(y_values.min(), y_values.max())
cmap = plt.cm.viridis
bar_colors = cmap(norm(y_values))
else:
# Use the fixed color palette
bar_colors = [plt.cm.tab10(i % 10) for i in range(len(x_values))]
# Create bars with the modern styling
bars = ax.bar(
x_values,
y_values,
color=bar_colors,
alpha=0.9,
width=0.6,
edgecolor='white',
linewidth=1
)
# Add value labels on the top of bars
for bar in bars:
height = bar.get_height()
if height > 0:
ax.text(
bar.get_x() + bar.get_width()/2.,
height * 1.01,
f'{height:.1f}',
ha='center',
va='bottom',
fontsize=9,
fontweight='bold',
color='#333333'
)
# Add labels and title withthe modern styling
ax.set_xlabel(x_col, fontsize=14, color='#333333')
ax.set_ylabel(y_col, fontsize=14, color='#333333')
ax.set_title(title, fontsize=16, fontweight='bold', color='#212121', pad=20)
# Style the grid
ax.grid(True, linestyle='--', alpha=0.3, color='#9E9E9E', axis='y')
ax.set_axisbelow(True) # Place grid behind bars
# Style the spines
for spine in ax.spines.values():
spine.set_visible(False)
# Style the ticks
ax.tick_params(axis='both', which='major', labelsize=11, colors='#555555')
# Rotate x-axis labels if there are many categories
if len(df) > 5:
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
# Convert plot to the image
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
# Return as HTML image
return pn.pane.HTML(f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);"/>')
def create_multibar_chart(df, category_col, bar_cols, title="Multi-Bar Chart"):
"""Create a modern-styled matplotlib multi-bar chart for comparing multiple metrics"""
# Set the modern style
plt.style.use('seaborn-v0_8-whitegrid')
fig, ax = plt.subplots(figsize=(12, 6), dpi=100)
fig.patch.set_facecolor('#F8F9FA')
ax.set_facecolor('#F8F9FA')
# Calculate the bar positions
categories = df[category_col].astype(str).tolist()
n_bars = len(bar_cols)
bar_width = 0.7 / n_bars
# Create positions for each bar group
positions = np.arange(len(categories))
# Create bars for each metric
for i, col in enumerate(bar_cols):
# Calculate the offset for this bar group
offset = (i - n_bars/2) * bar_width + bar_width/2
# Create bars with the modern styling
bars = ax.bar(
positions + offset,
df[col],
width=bar_width * 0.9,
color=plt.cm.Set2(i % 8),
alpha=0.9,
edgecolor='white',
linewidth=0.5,
label=col
)
# Add the value labels on top of bars
for bar in bars:
height = bar.get_height()
if height > 0:
ax.text(
bar.get_x() + bar.get_width()/2.,
height * 1.01,
f'{height:.1f}',
ha='center',
va='bottom',
fontsize=8,
fontweight='bold',
color='#333333'
)
# Set x-axis ticks and the labels
ax.set_xticks(positions)
ax.set_xticklabels(categories)
# Add labels and title with the modern styling
ax.set_xlabel(category_col, fontsize=14, color='#333333')
ax.set_ylabel("Value", fontsize=14, color='#333333')
ax.set_title(title, fontsize=16, fontweight='bold', color='#212121', pad=20)
# Style the grid
ax.grid(True, linestyle='--', alpha=0.3, color='#9E9E9E', axis='y')
ax.set_axisbelow(True)
# Style the spines
for spine in ax.spines.values():
spine.set_visible(False)
# Style the ticks
ax.tick_params(axis='both', which='major', labelsize=11, colors='#555555')
# Add legend with the modern styling
legend = ax.legend(
title="Metrics",
frameon=True,
facecolor='white',
edgecolor='none',
title_fontsize=12,
fontsize=10,
ncol=min(n_bars, 3),
loc='upper center',
bbox_to_anchor=(0.5, -0.15)
)
# Rotate x-axis labels if there are many categories
if len(categories) > 5:
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
# Convert the plot to image
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
# Return as HTML image
return pn.pane.HTML(f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);"/>')
def create_correlation_heatmap(df, columns=None, title="Correlation Matrix"):
"""Create a correlation heatmap for the specified columns"""
# Set modern style
plt.style.use('seaborn-v0_8-whitegrid')
# Use specific columns or all numeric columns
if columns is not None:
data_columns = [col for col in columns if col in df.columns]
else:
data_columns = df.select_dtypes(include=[np.number]).columns.tolist()
# Need at least 2 columns for correlation
if len(data_columns) < 2:
return pn.pane.Markdown("Not enough numeric columns for correlation analysis.")
# Calculate correlation matrix
corr_matrix = df[data_columns].corr().round(2)
# Create figure
fig, ax = plt.subplots(figsize=(10, 8), dpi=100)
fig.patch.set_facecolor('#F8F9FA')
# Create mask for upper triangle
mask = np.triu(np.ones_like(corr_matrix, dtype=bool))
# Generate a custom diverging colormap
cmap = sns.diverging_palette(230, 20, as_cmap=True)
# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(
corr_matrix,
mask=mask,
cmap=cmap,
vmax=1.0,
vmin=-1.0,
center=0,
square=True,
linewidths=.5,
cbar_kws={"shrink": .5},
annot=True, # Show correlation values
fmt=".2f", # Format as 2 decimal places
annot_kws={"size": 10} # Annotation text size
)
# Style the plot
plt.title(title, fontsize=16, fontweight='bold', color='#212121', pad=20)
plt.tight_layout()
# Convert plot to image
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
# Return as HTML image
return pn.pane.HTML(f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);"/>')
def create_map(center=[51.5074, -0.1278], zoom=10):
"""Create a base map for London"""
m = folium.Map(
location=center,
zoom_start=zoom,
tiles='CartoDB positron',
control_scale=True
)
# Add fullscreen control
Fullscreen().add_to(m)
# Add minimap
minimap = MiniMap(
toggle_display=True,
tile_layer='CartoDB positron',
position='bottomright'
)
m.add_child(minimap)
return m
def create_choropleth_map(gdf, value_column, title='Choropleth Map'):
"""Create a choropleth map for the given GeoDataFrame and value column"""
# Create base map
m = create_map()
# Get value range for choropleth
vmin = gdf[value_column].min()
vmax = gdf[value_column].max()
# Create a choropleth layer
colormap = cm.get_cmap('viridis')
# Add borough polygons with color based on value
for idx, row in gdf.iterrows():
# Normalize value for color mapping
if vmax > vmin:
norm_value = (row[value_column] - vmin) / (vmax - vmin)
else:
norm_value = 0.5
# Get color from colormap
rgba_color = colormap(norm_value)
hex_color = mcolors.rgb2hex(rgba_color)
# Create tooltip content
tooltip_html = f"""
<div style="font-family: Arial; max-width: 300px;">
<h4 style="margin: 0;">{row['name']}</h4>
<hr style="margin: 5px 0;">
<p><strong>{value_column}:</strong> {row[value_column]}</p>
<p><strong>Station Count:</strong> {int(row.get('Station_Count', 0))}</p>
<p><strong>Station Density:</strong> {row.get('Station_Density', 0):.2f} stations/km²</p>
"""
# Add additional metrics if available
for metric in ['Average_Income', 'Higher_Education_Rate', 'Social_Mobility_Score', 'Deprivation_Score']:
if metric in row and pd.notnull(row[metric]):
if 'Income' in metric:
tooltip_html += f"<p><strong>{metric.replace('_', ' ')}:</strong> £{int(row[metric]):,}</p>"
elif 'Rate' in metric:
tooltip_html += f"<p><strong>{metric.replace('_', ' ')}:</strong> {row[metric]:.1f}%</p>"
else:
tooltip_html += f"<p><strong>{metric.replace('_', ' ')}:</strong> {row[metric]:.2f}</p>"
tooltip_html += "</div>"
# Add polygon to map
folium.GeoJson(
row['geometry'].__geo_interface__,
style_function=lambda x, hex_color=hex_color: {
'fillColor': hex_color,
'color': '#263238',
'weight': 1,
'fillOpacity': 0.7
},
tooltip=folium.Tooltip(tooltip_html, sticky=True)
).add_to(m)
# Create a legend for the choropleth
legend_html = f"""
<div style="position: fixed;
bottom: 50px; right: 50px; z-index: 1000;
background-color: white;
padding: 10px; border-radius: 5px;
border: 1px solid grey;
opacity: 0.8;
font-family: Arial, sans-serif;">
<p style="margin-top: 0; margin-bottom: 5px; font-weight: bold;">{value_column}</p>
<div style="display: flex; align-items: center; margin-bottom: 3px;">
<div style="width: 20px; height: 20px; background-color: {mcolors.rgb2hex(colormap(0))}; margin-right: 5px;"></div>
<span>{vmin:.2f}</span>
</div>
<div style="display: flex; align-items: center; margin-bottom: 3px;">
<div style="width: 20px; height: 20px; background-color: {mcolors.rgb2hex(colormap(0.5))}; margin-right: 5px;"></div>
<span>{(vmin + vmax) / 2:.2f}</span>
</div>
<div style="display: flex; align-items: center; margin-bottom: 3px;">
<div style="width: 20px; height: 20px; background-color: {mcolors.rgb2hex(colormap(1))}; margin-right: 5px;"></div>
<span>{vmax:.2f}</span>
</div>
</div>
"""
# Add legend to map
m.get_root().html.add_child(folium.Element(legend_html))
# Return the map HTML
return m._repr_html_()
def add_station_markers(m, stations_gdf, cluster=True):
"""Add station markers to the map"""
if len(stations_gdf) == 0:
return m
if cluster:
# Create a marker cluster
marker_cluster = MarkerCluster(name="Transit Stations")
# Add markers to cluster
for idx, station in stations_gdf.iterrows():
# Create tooltip with station info
tooltip_html = f"""
<div style="font-family: Arial;">
<h4 style="margin: 0;">{station.get('NAME', 'Station')}</h4>
<p><strong>Zone:</strong> {station.get('Zone', 'N/A')}</p>
<p><strong>Lines:</strong> {station.get('LINES', 'N/A')}</p>
</div>
"""
# Add marker
folium.Marker(
location=[station.geometry.y, station.geometry.x],
tooltip=folium.Tooltip(tooltip_html, sticky=True),
icon=folium.Icon(color='blue', icon='train', prefix='fa')
).add_to(marker_cluster)
# Add cluster to map
m.add_child(marker_cluster)
else:
# Add individual markers
for idx, station in stations_gdf.iterrows():
# Create tooltip with station info
tooltip_html = f"""
<div style="font-family: Arial;">
<h4 style="margin: 0;">{station.get('NAME', 'Station')}</h4>
<p><strong>Zone:</strong> {station.get('Zone', 'N/A')}</p>
<p><strong>Lines:</strong> {station.get('LINES', 'N/A')}</p>
</div>
"""
# Add marker
folium.Marker(
location=[station.geometry.y, station.geometry.x],
tooltip=folium.Tooltip(tooltip_html, sticky=True),
icon=folium.Icon(color='blue', icon='train', prefix='fa')
).add_to(m)
return m
def add_property_heatmap(m, property_gdf):
"""Add property heatmap to the map"""
if len(property_gdf) == 0:
return m
# Create heatmap data
heatmap_data = [[row.geometry.y, row.geometry.x] for _, row in property_gdf.iterrows()]
# Add heatmap layer
HeatMap(
heatmap_data,
name="Property Density",
radius=15,
blur=10,
gradient={0.4: 'blue', 0.65: 'lime', 1: 'red'}
).add_to(m)
return m
def create_tabulator_table(df, title="Data Table", height=400):
"""Create an interactive table with the Tabulator widget"""
# Create a Tabulator widget
table = pn.widgets.Tabulator(
df,
header_filters=True,
width=None,
height=height,
sizing_mode='stretch_width',
pagination='remote',
page_size=10
)
# Create a container with the title and table
container = pn.Column(
pn.pane.Markdown(f"## {title}"),
table,
sizing_mode='stretch_width'
)
return container
def create_dashboard_card(title, value, color='#5E35B1', icon='bar_chart'):
"""Create a card with a metric and icon"""
card_html = f"""
<div style="background-color: white; border-radius: 8px; padding: 15px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
<div style="display: flex; justify-content: space-between; align-items: center;">
<div>
<div style="color: #666; font-size: 14px; font-weight: 500;">{title}</div>
<div style="font-size: 24px; font-weight: bold; color: {color}; margin-top: 5px;">{value}</div>
</div>
<div style="background-color: {color}20; width: 48px; height: 48px; border-radius: 50%; display: flex; justify-content: center; align-items: center;">
<span class="material-icons" style="color: {color}; font-size: 24px;">{icon}</span>
</div>
</div>
</div>
"""
return pn.pane.HTML(card_html, sizing_mode='stretch_width')
# ==========================================================
# 3. TRANSIT ACCESSIBILITY DASHBOARD
# ==========================================================
class TransitDashboard(param.Parameterized):
"""
An interactive dashboard for examining London's socioeconomic and transit accessibility.
Features:
- Interactive maps featuring station and borough information.
- Different kinds of charts for visualizing data.
- Tables of data for in-depth analysis.
- Perspectives and policy ramifications.
- Themes and filters that can be customized.
"""
# The Dashboard parameters
selected_borough = param.Selector(default=None)
property_distance_filter = param.Range(default=(0, 800), bounds=(0, 800))
socioeconomic_indicator = param.Selector(default='Transit_Accessibility_Index')
station_zone_filter = param.ListSelector(default=[])
visualization_mode = param.Selector(
default='Dashboard Overview',
objects=['Dashboard Overview', 'Map View', 'Chart View', 'Data Tables', 'Insights & Analysis']
)
chart_type = param.Selector(default='Scatter', objects=['Scatter', 'Bar', 'Correlation'])
color_theme = param.Selector(default='Indigo', objects=['Indigo', 'Teal', 'Deep Purple', 'Blue'])
def __init__(self, **params):
super().__init__(**params)
# Initialize the dashboard components
self._setup_themes()
self._initialize_data()
self.key_metrics = {} # Initialize empty key_metrics
self._calculate_key_metrics()
self._ensure_key_metrics_exist() # Ensure all required keys exist
self._build_dashboard()
def _ensure_key_metrics_exist(self):
"""Ensure all required key metrics exist with default values to avoid KeyError"""
default_metrics = {
'total_stations': 0,
'total_boroughs': 0,
'avg_stations_per_borough': 0.0,
'median_stations_per_borough': 0.0,
'min_stations': 0,
'max_stations': 0,
'most_stations_borough': 'N/A',
'most_stations_count': 0,
'best_transit_borough': 'N/A',
'best_transit_score': 0.0,
'avg_property_price': 0.0,
'median_property_price': 0.0,
'station_proximity_premium': 0.0,
'price_by_distance': {},
'zone_distribution': {},
'correlations': {},
'strongest_positive_corr': ('None', 0.0),
'strongest_negative_corr': ('None', 0.0)
}
# Add the default values for any missing keys
for key, default_value in default_metrics.items():
if key not in self.key_metrics:
self.key_metrics[key] = default_value
# --------------------------
# INITIALIZATION METHODS
# --------------------------
def _setup_themes(self):
"""Define color themes for the dashboard"""
self.theme_colors = {
'Indigo': {
'primary': '#3F51B5',
'secondary': '#E8EAF6',
'accent': '#FF4081',
'text': '#1A237E'
},
'Teal': {
'primary': '#009688',
'secondary': '#E0F2F1',
'accent': '#FF5722',
'text': '#004D40'
},
'Deep Purple': {
'primary': '#673AB7',
'secondary': '#EDE7F6',
'accent': '#FFC107',
'text': '#311B92'
},
'Blue': {
'primary': '#2196F3',
'secondary': '#E3F2FD',
'accent': '#FF9800',
'text': '#0D47A1'
}
}
def _initialize_data(self):
"""Initialize dashboard data and options"""
# Set the borough selection options
try:
if 'london_boroughs' in globals() and 'name' in london_boroughs.columns:
borough_names = sorted(london_boroughs['name'].unique().tolist())
self.param.selected_borough.objects = [None] + borough_names
else:
self.param.selected_borough.objects = [None]
except Exception as e:
print(f"Error initializing borough selector: {e}")
self.param.selected_borough.objects = [None]
# Set up the zone filter options
try:
if 'stations_data' in globals() and 'Zone' in stations_data.columns:
unique_zones = stations_data['Zone'].astype(str).str.split(',').explode().str.strip().unique()
unique_zones = sorted([z for z in unique_zones if z and z != 'nan'])
self.param.station_zone_filter.objects = unique_zones
self.station_zone_filter = unique_zones[:min(3, len(unique_zones))] # Default to first three zones or fewer
else:
self.param.station_zone_filter.objects = []
self.station_zone_filter = []
except Exception as e:
print(f"Error initializing zone filter: {e}")
self.param.station_zone_filter.objects = []
self.station_zone_filter = []
# Set the socioeconomic indicator options
self._setup_indicator_options()
def _setup_indicator_options(self):
"""Configure available socioeconomic indicators"""
indicator_options = []
try:
if 'london_boroughs' in globals():
# Core the transit indicators
for col in ['Transit_Accessibility_Index', 'Station_Density', 'Station_Count']:
if col in london_boroughs.columns:
indicator_options.append(col)
# Additional socioeconomic indicators
for col in ['Average_Income', 'Higher_Education_Rate', 'Unemployment_Rate',
'Deprivation_Score', 'Average_House_Price', 'Social_Mobility_Score']:
if col in london_boroughs.columns:
indicator_options.append(col)
# Fallback options if no indicators were found
if not indicator_options:
numeric_cols = london_boroughs.select_dtypes(include=[np.number]).columns.tolist()
if numeric_cols:
indicator_options = [numeric_cols[0]]
else:
for col in london_boroughs.columns:
if col != 'geometry':
indicator_options = [col]
break
# Set options and the default value
if indicator_options:
self.param.socioeconomic_indicator.objects = indicator_options
self.socioeconomic_indicator = indicator_options[0]
else:
# Default to empty if no options were found
self.param.socioeconomic_indicator.objects = ['No indicators available']
self.socioeconomic_indicator = 'No indicators available'
except Exception as e:
print(f"Error setting up indicator options: {e}")
self.param.socioeconomic_indicator.objects = ['Transit_Accessibility_Index']
self.socioeconomic_indicator = 'Transit_Accessibility_Index'
# --------------------------
# DATA PROCESSING METHODS
# --------------------------
def _calculate_key_metrics(self):
"""Calculate key metrics for the dashboard"""
try:
# Station metrics
self._calculate_station_metrics()
# Borough metrics
self._calculate_borough_metrics()
# Property metrics
self._calculate_property_metrics()
# Zone distribution
self._calculate_zone_distribution()
# Correlation analysis
self._calculate_correlations()
except Exception as e:
print(f"Error calculating key metrics: {e}")
def _calculate_station_metrics(self):
"""Calculate station-related metrics"""
try:
if 'stations_data' in globals():
self.key_metrics['total_stations'] = len(stations_data)
else:
self.key_metrics['total_stations'] = 0
if 'london_boroughs' in globals() and 'Station_Count' in london_boroughs.columns:
self.key_metrics.update({
'avg_stations_per_borough': london_boroughs['Station_Count'].mean(),
'median_stations_per_borough': london_boroughs['Station_Count'].median(),
'min_stations': london_boroughs['Station_Count'].min(),
'max_stations': london_boroughs['Station_Count'].max(),
})
# Find the borough with most stations
max_idx = london_boroughs['Station_Count'].idxmax()
self.key_metrics.update({
'most_stations_borough': london_boroughs.loc[max_idx, 'name'],
'most_stations_count': london_boroughs.loc[max_idx, 'Station_Count']
})
except Exception as e:
print(f"Error calculating station metrics: {e}")
def _calculate_borough_metrics(self):
"""Calculate borough-related metrics"""
try:
if 'london_boroughs' in globals():
self.key_metrics['total_boroughs'] = len(london_boroughs)
if 'Transit_Accessibility_Index' in london_boroughs.columns:
max_idx = london_boroughs['Transit_Accessibility_Index'].idxmax()
self.key_metrics.update({
'best_transit_borough': london_boroughs.loc[max_idx, 'name'],
'best_transit_score': london_boroughs.loc[max_idx, 'Transit_Accessibility_Index'],
'transit_accessibility_percentiles': {
'25%': london_boroughs['Transit_Accessibility_Index'].quantile(0.25),
'50%': london_boroughs['Transit_Accessibility_Index'].quantile(0.50),
'75%': london_boroughs['Transit_Accessibility_Index'].quantile(0.75)
}
})
except Exception as e:
print(f"Error calculating borough metrics: {e}")
def _calculate_property_metrics(self):
"""Calculate property-related metrics"""
# Initialize the default values
self.key_metrics['avg_property_price'] = 0
self.key_metrics['median_property_price'] = 0
self.key_metrics['station_proximity_premium'] = 0
self.key_metrics['price_by_distance'] = {}
self.key_metrics['property_type_counts'] = {}
try:
if 'property_data' in globals() and 'Price' in property_data.columns:
self.key_metrics.update({
'avg_property_price': property_data['Price'].mean(),
'median_property_price': property_data['Price'].median(),
})
if 'Property_Type' in property_data.columns:
self.key_metrics['property_type_counts'] = property_data['Property_Type'].value_counts().to_dict()
if 'Distance_Band' in property_data.columns:
price_by_distance = property_data.groupby('Distance_Band')['Price'].mean()
self.key_metrics['price_by_distance'] = price_by_distance.to_dict()
if '0-200m' in price_by_distance and '600-800m' in price_by_distance:
nearby_price = price_by_distance['0-200m']
far_price = price_by_distance['600-800m']
if far_price > 0:
self.key_metrics['station_proximity_premium'] = ((nearby_price - far_price) / far_price) * 100
except Exception as e:
print(f"Error calculating property metrics: {e}")
def _calculate_zone_distribution(self):
"""Calculate zone distribution metrics"""
self.key_metrics['zone_distribution'] = {}
try:
if 'stations_data' in globals() and 'Zone' in stations_data.columns:
all_zones = stations_data['Zone'].astype(str).str.split(',').explode().str.strip()
zone_counts = all_zones.value_counts()
self.key_metrics['zone_distribution'] = zone_counts.to_dict()
except Exception as e:
print(f"Error calculating zone distribution: {e}")
def _calculate_correlations(self):
"""Calculate correlation metrics"""
self.key_metrics['correlations'] = {}
self.key_metrics['strongest_positive_corr'] = ("None", 0)
self.key_metrics['strongest_negative_corr'] = ("None", 0)
try:
# If correlation_data exists, use it
if 'correlation_data' in globals() and isinstance(correlation_data, dict) and len(correlation_data) > 0:
self.key_metrics['correlations'] = correlation_data
# Find the strongest correlations
pos_corrs = {k: v for k, v in correlation_data.items() if v > 0}
if pos_corrs:
self.key_metrics['strongest_positive_corr'] = (max(pos_corrs, key=pos_corrs.get), pos_corrs[max(pos_corrs, key=pos_corrs.get)])
neg_corrs = {k: v for k, v in correlation_data.items() if v < 0}
if neg_corrs:
self.key_metrics['strongest_negative_corr'] = (min(neg_corrs, key=neg_corrs.get), neg_corrs[min(neg_corrs, key=neg_corrs.get)])
# Otherwise, calculate correlations if london_boroughs exists
elif 'london_boroughs' in globals() and 'Transit_Accessibility_Index' in london_boroughs.columns:
corr_columns = [
'Transit_Accessibility_Index', 'Station_Density', 'Average_Income',
'Higher_Education_Rate', 'Unemployment_Rate', 'Average_House_Price'
]
available_columns = [col for col in corr_columns if col in london_boroughs.columns]
if len(available_columns) > 1:
corr_matrix = london_boroughs[available_columns].corr()
if 'Transit_Accessibility_Index' in corr_matrix.columns:
transit_corrs = corr_matrix['Transit_Accessibility_Index'].drop('Transit_Accessibility_Index')
# Convert to dictionary for the storage
self.key_metrics['correlations'] = transit_corrs.to_dict()
# Find strongest positive correlation
pos_corrs = transit_corrs[transit_corrs > 0]
if not pos_corrs.empty:
max_idx = pos_corrs.idxmax()
self.key_metrics['strongest_positive_corr'] = (max_idx, pos_corrs[max_idx])
# Find the strongest negative correlation
neg_corrs = transit_corrs[transit_corrs < 0]
if not neg_corrs.empty:
min_idx = neg_corrs.idxmin()
self.key_metrics['strongest_negative_corr'] = (min_idx, neg_corrs[min_idx])
except Exception as e:
print(f"Error calculating correlations: {e}")
def _filter_data(self):
"""Filter the borough data based on user selections"""
try:
if 'london_boroughs' in globals():
filtered_boroughs = london_boroughs.copy()
if self.selected_borough:
filtered_boroughs = filtered_boroughs[filtered_boroughs['name'] == self.selected_borough]
return filtered_boroughs
else:
return pd.DataFrame() # Return empty DataFrame if data not available
except Exception as e:
print(f"Error filtering data: {e}")
return pd.DataFrame() # Return empty DataFrame on error
# --------------------------
# VISUALIZATION METHODS
# --------------------------
def _build_dashboard(self):
"""Build the main dashboard layout with aligned filters and controls"""
theme = self.theme_colors[self.color_theme]
# Header
header = pn.Column(
pn.pane.Markdown(
f"# London Transit Accessibility Dashboard",
styles=dict(
color=theme['text'],
font_size='32px',
text_align='center',
font_weight='bold',
margin='10px 0'
)
),
pn.pane.Markdown(
"### Exploring the relationship between public transport and socioeconomic factors across London",
styles=dict(
color='#555555',
font_style='italic',
text_align='center',
margin='0 0 15px 0'
)
),
sizing_mode='stretch_width'
)
# Theme selector with more visible styling
theme_selector = pn.Row(
pn.pane.Markdown("**Dashboard Theme:**", styles=dict(margin='5px 10px 0 0')),
pn.Param(
self.param.color_theme,
widgets={'color_theme': pn.widgets.RadioButtonGroup(button_type='primary')},
name=""
),
align='center',
styles=dict(
background=theme['secondary'],
padding='5px 15px',
border_radius='5px',
margin='0 0 10px 0'
)
)
# Key metrics
metrics_row = self._create_key_metrics_row(theme)
# =========================================================
# FIXED STATION ZONES ALIGNMENT IN CONTROLS SECTION
# =========================================================
# Common styles for all the boxes
box_style = dict(
background='white',
border_radius='8px',
box_shadow='0 2px 5px rgba(0,0,0,0.08)',
margin_bottom='15px',
width='100%' # Ensure all boxes have same width
)
# Common styles for all the section headers
header_style = dict(
color='white',
background=theme['primary'],
padding='12px 15px',
border_radius='8px 8px 0 0',
font_weight='600',
font_size='16px',
margin='0'
)
# Common styles for all the section content areas
content_style = dict(
padding='15px',
border=f'1px solid {theme["secondary"]}',
border_top='none',
border_radius='0 0 8px 8px'
)
# Main container for controls with th improved styling
controls = pn.Column(
# Header with modern styling and the icon
pn.pane.HTML(f"""
<div style="text-align: center; padding: 18px; margin-bottom: 20px;
background: linear-gradient(120deg, {theme['primary']}dd, {theme['primary']});
color: white; border-radius: 12px; box-shadow: 0 4px 10px rgba(0,0,0,0.15);">
<div style="display: flex; align-items: center; justify-content: center;">
<span class="material-icons" style="font-size: 24px; margin-right: 10px;">tune</span>
<h2 style="margin: 0; font-size: 22px; font-weight: 500;">Filters & Controls</h2>
</div>
</div>
"""),
# View Mode Section
pn.Column(
pn.pane.HTML(f"""
<div style="color: white; background: {theme['primary']};
padding: 12px 15px; border-radius: 8px 8px 0 0;
font-weight: 600; font-size: 16px; margin: 0;
display: flex; align-items: center;">
<span class="material-icons" style="margin-right: 8px;"></span>
View Mode
</div>
"""),
pn.Column(
pn.Param(
self.param.visualization_mode,
widgets={'visualization_mode': pn.widgets.RadioBoxGroup(
options=['Dashboard Overview', 'Map View', 'Chart View', 'Data Tables', 'Insights & Analysis'],
inline=False
)},
name=""
),
styles=content_style
),
styles=box_style
),
# Chart Type Selector with the conditional visibility
pn.Param(
self.param.chart_type,
name="Chart Type",
widgets={'chart_type': pn.widgets.RadioBoxGroup(
options=['Scatter', 'Bar', 'Correlation'],
inline=True
)},
visible=False,
styles=dict(
background='white',
padding='10px 15px',
border_radius='8px',
margin_bottom='15px',
box_shadow='0 2px 5px rgba(0,0,0,0.08)'
)
),
# Borough Selection Section
pn.Column(
pn.pane.HTML(f"""
<div style="color: white; background: {theme['primary']};
padding: 12px 15px; border-radius: 8px 8px 0 0;
font-weight: 600; font-size: 16px; margin: 0;
display: flex; align-items: center;">
<span class="material-icons" style="margin-right: 8px;">location_city</span>
Borough Selection
</div>
"""),
pn.Column(
pn.Param(
self.param.selected_borough,
name="",
widgets={
'selected_borough': pn.widgets.Select(
options=self.param.selected_borough.objects
)
}
),
styles=content_style
),
styles=box_style
),
# Data Indicators Section
pn.Column(
pn.pane.HTML(f"""
<div style="color: white; background: {theme['primary']};
padding: 12px 15px; border-radius: 8px 8px 0 0;
font-weight: 600; font-size: 16px; margin: 0;
display: flex; align-items: center;">
<span class="material-icons" style="margin-right: 8px;">insert_chart</span>
Data Indicators
</div>
"""),
pn.Column(
pn.pane.Markdown("**Select a socioeconomic indicator to display:**",
styles=dict(
font_size='14px',
margin='0 0 10px 0'
)
),
pn.Param(
self.param.socioeconomic_indicator,
name="",
widgets={
'socioeconomic_indicator': pn.widgets.Select(
options=self.param.socioeconomic_indicator.objects
)
}
),
styles=content_style
),
styles=box_style
),
# Station Filters Section
pn.Column(
pn.pane.HTML(f"""
<div style="color: white; background: {theme['primary']};
padding: 12px 15px; border-radius: 8px 8px 0 0;
font-weight: 600; font-size: 16px; margin: 0;
display: flex; align-items: center;">
<span class="material-icons" style="margin-right: 8px;">train</span>
Station Filters
</div>
"""),
pn.Column(
pn.pane.Markdown("**Station Zones:**",
styles=dict(
font_size='14px',
margin='0 0 10px 0'
)
),
# Use a scrollable container with fixed height for the zones
pn.pane.HTML(f"""
<div style="max-height: 150px; overflow-y: auto; border: 1px solid {theme['secondary']};
border-radius: 4px; padding: 10px; margin-bottom: 15px;">
"""),
pn.Param(
self.param.station_zone_filter,
name="",
widgets={
'station_zone_filter': pn.widgets.CheckBoxGroup(
options=self.param.station_zone_filter.objects,
inline=False,
styles={
'width': '100%'
}
)
}
),
pn.pane.HTML("</div>"),
pn.pane.Markdown("**Property Distance from Station (m):**",
styles=dict(
font_size='14px',
margin='5px 0 10px 0'
)
),
pn.Param(
self.param.property_distance_filter,
name="",
widgets={
'property_distance_filter': pn.widgets.RangeSlider(
start=0,
end=800,
step=50,
show_value=True
)
}
),
styles=content_style
),
styles=box_style
),
# Data Summary Section
pn.Column(
pn.pane.HTML(f"""
<div style="color: white; background: {theme['primary']};
padding: 12px 15px; border-radius: 8px 8px 0 0;
font-weight: 600; font-size: 16px; margin: 0;
display: flex; align-items: center;">
<span class="material-icons" style="margin-right: 8px;">summarize</span>
Data Summary
</div>
"""),
pn.Column(
pn.panel(self._create_data_summary, sizing_mode='stretch_width'),
styles=content_style
),
styles=box_style
),
# Container styling
width=340,
margin=10,
sizing_mode='fixed',
styles=dict(
background='#f8f9fa',
border_radius='12px',
box_shadow='0 4px 12px rgba(0, 0, 0, 0.1)',
padding='20px',
height='100%'
)
)
# Make visualization depend on the chart_type
self.param.chart_type.precedence = 1
# Main content area
main_content = pn.Column(
pn.panel(self._create_visualization, sizing_mode='stretch_both'),
pn.panel(self._create_correlation_table, sizing_mode='stretch_width'),
sizing_mode='stretch_both'
)
# Footer
footer = pn.Row(
pn.pane.Markdown(
"**Data sources:** London transit station data, borough boundaries, socioeconomic indicators, and property transactions data",
styles=dict(color='#757575', font_size='0.9em', margin='0')
),
pn.pane.Markdown(
f"**Dashboard Version:** 2.0 | **Total Records:** {len(stations_data) if 'stations_data' in globals() else 0:,} stations, {len(london_boroughs) if 'london_boroughs' in globals() else 0:,} boroughs",
styles=dict(color='#757575', font_size='0.9em', text_align='right', margin='0')
),
sizing_mode='stretch_width'
)
# Final dashboard layout
self.dashboard = pn.Column(
header,
theme_selector,
metrics_row,
pn.Row(
controls,
main_content,
sizing_mode='stretch_both'
),
pn.layout.Divider(styles=dict(margin='10px 0')),
footer,
sizing_mode='stretch_width',
styles=dict(padding='15px')
)
def _create_key_metrics_row(self, theme):
"""Create a row of key metric cards"""
cards = [
self._create_metric_card(
title="Transit Stations",
value=f"{self.key_metrics.get('total_stations', 0):,}",
icon="train",
color=theme['primary'],
subtitle=f"Across {self.key_metrics.get('total_boroughs', 0)} boroughs",
footer_text=f"Most in {self.key_metrics.get('most_stations_borough', 'N/A')}: {int(self.key_metrics.get('most_stations_count', 0))}"
),
self._create_metric_card(
title="Average Stations per Borough",
value=f"{self.key_metrics.get('avg_stations_per_borough', 0):.1f}",
icon="location_city",
color=theme['primary'],
subtitle=f"Median: {self.key_metrics.get('median_stations_per_borough', 0):.1f}",
footer_text=f"Range: {int(self.key_metrics.get('min_stations', 0))} - {int(self.key_metrics.get('max_stations', 0))}"
),
self._create_metric_card(
title="Best Transit Borough",
value=f"{self.key_metrics.get('best_transit_borough', 'N/A')}",
icon="star",
color=theme['primary'],
subtitle=f"Score: {self.key_metrics.get('best_transit_score', 0):.2f}",
footer_text="Based on Transit Accessibility Index"
)
]
# Add property or the correlation card
avg_property_price = self.key_metrics.get('avg_property_price', 0)
if avg_property_price > 0:
cards.append(
self._create_metric_card(
title="Station Proximity Premium",
value=f"{self.key_metrics.get('station_proximity_premium', 0):.1f}%",
icon="home",
color=theme['primary'],
subtitle=f"Avg. Price: £{avg_property_price:,.0f}",
footer_text="Price premium for properties near stations"
)
)
else:
pos_indicator, pos_value = self.key_metrics.get('strongest_positive_corr', ('None', 0))
cards.append(
self._create_metric_card(
title="Correlation Strength",
value=f"{pos_value:.2f}",
icon="trending_up",
color=theme['primary'],
subtitle=f"With {pos_indicator}",
footer_text="Correlation coefficient with transit access"
)
)
# Create metrics row with the equal width columns
return pn.Row(
*[pn.Column(card, sizing_mode='stretch_width') for card in cards],
sizing_mode='stretch_width'
)
def _create_metric_card(self, title, value, icon="bar_chart", color="#5E35B1", subtitle=None, footer_text=None):
"""Create a card with a metric, icon, and optional footer"""
subtitle_html = f'<div style="font-size: 14px; color: #666; margin-top: 3px;">{subtitle}</div>' if subtitle else ''
footer_html = f'''
<div style="border-top: 1px solid #eee; margin-top: 10px; padding-top: 8px;
font-size: 12px; color: #666; white-space: normal; overflow: hidden;
text-overflow: ellipsis; line-height: 1.4;">
{footer_text}
</div>
''' if footer_text else ''
card_html = f"""
<div style="background-color: white; border-radius: 10px; padding: 15px;
box-shadow: 0 2px 4px rgba(0,0,0,0.1); height: 100%;
display: flex; flex-direction: column; justify-content: space-between;">
<div>
<div style="display: flex; justify-content: space-between; align-items: flex-start;">
<div style="flex-grow: 1; overflow: hidden;">
<div style="color: #666; font-size: 14px; font-weight: 500; white-space: nowrap;
overflow: hidden; text-overflow: ellipsis;">
{title}
</div>
<div style="font-size: 24px; font-weight: bold; color: {color}; margin-top: 5px;
white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">
{value}
</div>
{subtitle_html}
</div>
<div style="background-color: {color}20; min-width: 48px; height: 48px; border-radius: 50%;
display: flex; justify-content: center; align-items: center; margin-left: 10px;">
<span class="material-icons" style="color: {color}; font-size: 24px;">{icon}</span>
</div>
</div>
</div>
{footer_html}
</div>
"""
return pn.pane.HTML(card_html, sizing_mode='stretch_width')
@param.depends('selected_borough', 'station_zone_filter', 'property_distance_filter', 'color_theme')
def _create_data_summary(self):
"""Create a summary of the current data selection"""
theme = self.theme_colors[self.color_theme]
try:
# Borough summary
if self.selected_borough and 'london_boroughs' in globals():
borough_data = london_boroughs[london_boroughs['name'] == self.selected_borough]
if len(borough_data) > 0:
row = borough_data.iloc[0]
summary_parts = [f"### {self.selected_borough}"]
metrics_available = False
for metric in ['Transit_Accessibility_Index', 'Station_Count', 'Station_Density',
'Average_Income', 'Average_House_Price', 'Higher_Education_Rate',
'Unemployment_Rate', 'Deprivation_Score', 'Social_Mobility_Score']:
if metric in row and pd.notnull(row[metric]):
metrics_available = True
if metric == 'Transit_Accessibility_Index':
summary_parts.append(f"- **Transit Accessibility Index**: {row[metric]:.2f}")
elif metric == 'Station_Count':
summary_parts.append(f"- **Station Count**: {int(row[metric])}")
elif metric == 'Station_Density':
summary_parts.append(f"- **Station Density**: {row[metric]:.2f} stations/km²")
elif 'Price' in metric or 'Income' in metric:
summary_parts.append(f"- **{metric.replace('_', ' ')}**: £{int(row[metric]):,}")
elif 'Rate' in metric:
summary_parts.append(f"- **{metric.replace('_', ' ')}**: {row[metric]:.1f}%")
else:
summary_parts.append(f"- **{metric.replace('_', ' ')}**: {row[metric]:.2f}")
if not metrics_available:
summary_parts.append("*No detailed metrics available for this borough*")
return pn.pane.Markdown(
"\n".join(summary_parts),
styles=dict(
background=theme['secondary'],
padding='10px',
border_radius='5px',
border_left=f'4px solid {theme["primary"]}'
)
)
# General data summary
total_boroughs = len(london_boroughs) if 'london_boroughs' in globals() else 0
total_stations = len(stations_data) if 'stations_data' in globals() else 0
summary_parts = [
"### Current Selection",
f"- **Total Boroughs**: {total_boroughs}",
f"- **Total Stations**: {total_stations}",
f"- **Selected Zones**: {', '.join(self.station_zone_filter) if self.station_zone_filter else 'All'}",
f"- **Property Distance Filter**: {self.property_distance_filter[0]}-{self.property_distance_filter[1]}m"
]
if 'london_boroughs' in globals() and self.socioeconomic_indicator in london_boroughs.columns:
indicator_values = london_boroughs[self.socioeconomic_indicator].dropna()
if len(indicator_values) > 0:
summary_parts.append(f"- **{self.socioeconomic_indicator} Range**: {indicator_values.min():.2f} - {indicator_values.max():.2f}")
return pn.pane.Markdown(
"\n".join(summary_parts),
styles=dict(
background=theme['secondary'],
padding='10px',
border_radius='5px',
border_left=f'4px solid {theme["primary"]}'
)
)
except Exception as e:
print(f"Error creating data summary: {e}")
return pn.pane.Markdown(
"Error loading data summary. Please check your data sources.",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
@param.depends('visualization_mode', 'chart_type', 'selected_borough', 'socioeconomic_indicator', 'station_zone_filter',
'property_distance_filter', 'color_theme')
def _create_visualization(self):
"""Create the main visualization based on selected parameters"""
theme = self.theme_colors[self.color_theme]
try:
# Show/hide chart type selector
if self.visualization_mode == 'Chart View':
self.param.chart_type.precedence = 1
else:
self.param.chart_type.precedence = -1
filtered_boroughs = self._filter_data()
if self.visualization_mode == 'Dashboard Overview':
return self._create_dashboard_overview(filtered_boroughs, theme)
elif self.visualization_mode == 'Map View':
return self._create_map_view(filtered_boroughs, theme)
elif self.visualization_mode == 'Chart View':
return self._create_chart_view(filtered_boroughs, theme)
elif self.visualization_mode == 'Data Tables':
return self._create_data_tables(filtered_boroughs, theme)
elif self.visualization_mode == 'Insights & Analysis':
return self._create_insights_view(filtered_boroughs, theme)
else:
return pn.pane.Markdown("Select a visualization mode")
except Exception as e:
print(f"Error creating visualization: {e}")
return pn.pane.Markdown(
f"Error creating visualization: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_dashboard_overview(self, filtered_boroughs, theme):
"""Create dashboard overview with multiple visualization types"""
try:
overview_title = pn.pane.Markdown(
"## Dashboard Overview",
styles=dict(
color=theme['text'],
font_size='24px',
text_align='center',
margin='0 0 15px 0'
)
)
return pn.Column(
overview_title,
self._create_quick_insights(filtered_boroughs, theme),
pn.Row(
pn.Column(
pn.pane.Markdown("### Transit Accessibility Map", styles=dict(margin='0 0 10px 0')),
self._create_compact_map(filtered_boroughs, theme),
pn.pane.Markdown("### Property Analysis", styles=dict(margin='20px 0 10px 0')),
self._create_property_summary(theme),
sizing_mode='stretch_width'
),
pn.Column(
pn.pane.Markdown("### Socioeconomic Correlation", styles=dict(margin='0 0 10px 0')),
self._create_compact_chart(filtered_boroughs, theme),
pn.pane.Markdown("### Station Zone Distribution", styles=dict(margin='20px 0 10px 0')),
self._create_zone_distribution(theme),
sizing_mode='stretch_width'
),
sizing_mode='stretch_width'
),
pn.pane.Markdown(
"""
### Getting Started
This dashboard offers thorough insights into how socioeconomic factors and transit accessibility
relate to one another throughout London. Explore the various views by using the navigation options.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='15px 0',
border_left=f'4px solid {theme["primary"]}'
)
),
sizing_mode='stretch_width'
)
except Exception as e:
print(f"Error creating dashboard overview: {e}")
return pn.pane.Markdown(
f"Error creating dashboard overview: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_quick_insights(self, filtered_boroughs, theme):
"""Create a quick insights panel"""
try:
# Safe access to the DataFrame min/max values with try-except
transit_min = 0
transit_max = 0
try:
if 'Transit_Accessibility_Index' in filtered_boroughs.columns and not filtered_boroughs.empty:
transit_min = filtered_boroughs['Transit_Accessibility_Index'].min()
transit_max = filtered_boroughs['Transit_Accessibility_Index'].max()
except Exception:
pass
insights_html = f"""
<div style="background-color: {theme['secondary']}; padding: 15px; border-radius: 5px;
margin-bottom: 15px; border-left: 4px solid {theme['primary']};">
<h3 style="margin-top: 0; color: {theme['text']};">Quick Insights</h3>
<div style="display: flex; flex-wrap: wrap; gap: 10px;">
<div style="flex: 1; min-width: 200px; background: white; padding: 10px; border-radius: 5px;
box-shadow: 0 1px 3px rgba(0,0,0,0.1);">
<div style="font-weight: bold; color: {theme['primary']};">Transit Distribution</div>
<div style="font-size: 13px; margin-top: 5px;">
The central boroughs of London have a greater concentration of transit stations.
{int(self.key_metrics['avg_stations_per_borough'])} stations per borough on average,
with a range from {int(self.key_metrics['min_stations'])} to
{int(self.key_metrics['max_stations'])}.
</div>
</div>
<div style="flex: 1; min-width: 200px; background: white; padding: 10px; border-radius: 5px;
box-shadow: 0 1px 3px rgba(0,0,0,0.1);">
<div style="font-weight: bold; color: {theme['primary']};">Accessibility Metrics</div>
<div style="font-size: 13px; margin-top: 5px;">
The Transit Accessibility Index ranges from
{transit_min:.2f} to
{transit_max:.2f} across boroughs,
with central areas scoring highest.
</div>
</div>
"""
# Add correlation insight if it's available
if 'strongest_positive_corr' in self.key_metrics:
pos_indicator, pos_value = self.key_metrics['strongest_positive_corr']
insights_html += f"""
<div style="flex: 1; min-width: 200px; background: white; padding: 10px; border-radius: 5px;
box-shadow: 0 1px 3px rgba(0,0,0,0.1);">
<div style="font-weight: bold; color: {theme['primary']};">Strongest Correlation</div>
<div style="font-size: 13px; margin-top: 5px;">
Transit accessibility shows a {abs(pos_value):.2f} correlation with {pos_indicator},
suggesting a significant relationship between transit access and this socioeconomic
factor.
</div>
</div>
"""
# Add property insight if it's available
if self.key_metrics['avg_property_price'] > 0:
insights_html += f"""
<div style="flex: 1; min-width: 200px; background: white; padding: 10px; border-radius: 5px;
box-shadow: 0 1px 3px rgba(0,0,0,0.1);">
<div style="font-weight: bold; color: {theme['primary']};">Property Impact</div>
<div style="font-size: 13px; margin-top: 5px;">
Properties within 200m of stations command a premium of approximately
{self.key_metrics['station_proximity_premium']:.1f}% compared to those 600-800m
away.
</div>
</div>
"""
insights_html += """
</div>
</div>
"""
return pn.pane.HTML(insights_html, sizing_mode='stretch_width')
except Exception as e:
print(f"Error creating quick insights: {e}")
return pn.pane.Markdown(
"Unable to load insights due to an error.",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_compact_map(self, filtered_boroughs, theme):
"""Create a compact map for the dashboard overview"""
try:
if 'create_map' not in globals():
return pn.pane.Markdown(
"Map visualization function not available. Please ensure 'create_map' function is defined.",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
if self.socioeconomic_indicator not in filtered_boroughs.columns:
return pn.pane.Markdown(
f"Error: Selected indicator '{self.socioeconomic_indicator}' not found in data.",
styles=dict(color='red')
)
# Create map placeholder with message to maintain the layout
map_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 300px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 48px; color: {theme['primary']};">map</span>
<p style="margin-top: 10px;">Interactive map will load here when data is available</p>
<p style="font-size: 0.9em; opacity: 0.7;">Showing {len(filtered_boroughs)} boroughs with {self.socioeconomic_indicator} data</p>
</div>
</div>
"""
# Try to generate actual map with folium if possible
try:
if 'create_map' in globals() and 'cm' in globals() and 'folium' in globals() and 'mcolors' in globals():
m = create_map()
# Add the simplified choropleth layer
all_values = filtered_boroughs[self.socioeconomic_indicator].dropna()
if len(all_values) > 0:
vmin, vmax = all_values.min(), all_values.max()
colormap = cm.get_cmap('viridis')
for idx, row in filtered_boroughs.iterrows():
value = row.get(self.socioeconomic_indicator, 0)
norm_value = (value - vmin) / (vmax - vmin) if vmax > vmin else 0.5
rgba_color = colormap(norm_value)
hex_color = mcolors.rgb2hex(rgba_color)
tooltip_html = f"{row['name']}: {value:.2f}"
folium.GeoJson(
row['geometry'].__geo_interface__,
style_function=lambda x, hex_color=hex_color: {
'fillColor': hex_color,
'color': '#263238',
'weight': 1,
'fillOpacity': 0.7
},
tooltip=tooltip_html
).add_to(m)
# Add the station markers if available
if 'stations_gdf' in globals():
try:
if 'Zone' in stations_gdf.columns and self.station_zone_filter:
filtered_stations = stations_gdf[
stations_gdf['Zone'].astype(str).str.contains('|'.join(self.station_zone_filter))
]
filtered_stations = filtered_stations.sample(min(100, len(filtered_stations)))
else:
filtered_stations = stations_gdf.sample(min(100, len(stations_gdf)))
station_cluster = MarkerCluster(name="Transit Stations")
for _, station in filtered_stations.iterrows():
folium.CircleMarker(
location=[station.geometry.y, station.geometry.x],
radius=3,
color='blue',
fill=True,
fill_opacity=0.7,
tooltip=station.get('NAME', 'Station')
).add_to(station_cluster)
m.add_child(station_cluster)
except Exception as e:
print(f"Error adding station markers to compact map: {e}")
# Add the legend
legend_html = f"""
<div style="position: fixed; bottom: 10px; right: 10px; z-index: 1000;
background-color: white; padding: 5px; border-radius: 5px;
border: 1px solid grey; opacity: 0.8; font-size: 12px;">
<div>{self.socioeconomic_indicator}</div>
<div style="display: flex; align-items: center;">
<div style="width: 15px; height: 15px; background-color: {mcolors.rgb2hex(colormap(0))};
margin-right: 5px;"></div>
<span>{vmin:.1f}</span>
<div style="width: 15px; height: 15px; background-color: {mcolors.rgb2hex(colormap(1))};
margin: 0 5px 0 10px;"></div>
<span>{vmax:.1f}</span>
</div>
</div>
"""
m.get_root().html.add_child(folium.Element(legend_html))
return pn.pane.HTML(m._repr_html_(), height=300, sizing_mode='stretch_width')
except Exception as e:
print(f"Error creating folium map: {e}")
# Return the placeholder if actual map creation failed
return pn.pane.HTML(map_html, height=300, sizing_mode='stretch_width')
except Exception as e:
print(f"Error in compact map creation: {e}")
return pn.pane.Markdown(f"Error creating map: {e}")
def _create_compact_chart(self, filtered_boroughs, theme):
"""Create a compact chart for the dashboard overview"""
try:
if 'Transit_Accessibility_Index' not in filtered_boroughs.columns or self.socioeconomic_indicator not in filtered_boroughs.columns:
# Create a placeholder chart when the data is unavailable
chart_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 300px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 48px; color: {theme['primary']};">bar_chart</span>
<p style="margin-top: 10px;">Chart will load here when data is available</p>
<p style="font-size: 0.9em; opacity: 0.7;">Required data columns not available</p>
</div>
</div>
"""
return pn.pane.HTML(chart_html, sizing_mode='stretch_width')
if filtered_boroughs.empty:
chart_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 300px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 48px; color: {theme['primary']};">warning</span>
<p style="margin-top: 10px;">No data available for the selected filters</p>
<p style="font-size: 0.9em; opacity: 0.7;">Try adjusting your borough selection</p>
</div>
</div>
"""
return pn.pane.HTML(chart_html, sizing_mode='stretch_width')
# Create the matplotlib chart if libraries are available
try:
import matplotlib.pyplot as plt
import numpy as np
import io
import base64
plt.style.use('seaborn-v0_8-whitegrid')
fig, ax = plt.subplots(figsize=(8, 4), dpi=80)
fig.patch.set_facecolor('#F8F9FA')
ax.set_facecolor('#F8F9FA')
x = filtered_boroughs['Transit_Accessibility_Index']
y = filtered_boroughs[self.socioeconomic_indicator]
ax.scatter(
x, y,
color=theme['primary'],
alpha=0.7,
s=50,
edgecolor='white',
linewidth=0.5
)
if len(filtered_boroughs) > 1:
m, b = np.polyfit(x, y, 1)
x_line = np.linspace(x.min(), x.max(), 100)
y_line = m * x_line + b
ax.plot(x_line, y_line, color=theme['accent'], linestyle='-', linewidth=2, alpha=0.7)
corr = round(x.corr(y), 2)
ax.text(
0.05, 0.95,
f'r = {corr}',
transform=ax.transAxes,
fontsize=10,
fontweight='bold',
verticalalignment='top',
bbox=dict(
boxstyle='round,pad=0.3',
facecolor='white',
alpha=0.8,
edgecolor='none'
)
)
ax.set_xlabel('Transit Accessibility Index')
ax.set_ylabel(self.socioeconomic_indicator)
ax.set_title(f"Transit Accessibility vs {self.socioeconomic_indicator}")
for spine in ax.spines.values():
spine.set_visible(False)
plt.tight_layout()
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=80, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
return pn.pane.HTML(
f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 5px; max-height: 300px;">',
sizing_mode='stretch_width'
)
except Exception as e:
print(f"Error creating matplotlib chart: {e}")
# Fall back to placeholder
chart_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 300px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 48px; color: {theme['primary']};">bar_chart</span>
<p style="margin-top: 10px;">Chart visualization could not be rendered</p>
<p style="font-size: 0.9em; opacity: 0.7;">Required libraries may be missing</p>
</div>
</div>
"""
return pn.pane.HTML(chart_html, sizing_mode='stretch_width')
except Exception as e:
print(f"Error creating compact chart: {e}")
return pn.pane.Markdown(f"Error creating chart: {e}")
def _create_property_summary(self, theme):
"""Create a property price summary by distance from station"""
try:
if 'price_by_distance' not in self.key_metrics or not self.key_metrics['price_by_distance']:
# Create placeholder when the data is unavailable
chart_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 300px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 48px; color: {theme['primary']};">home</span>
<p style="margin-top: 10px;">Property data not available</p>
<p style="font-size: 0.9em; opacity: 0.7;">Please ensure property data is loaded</p>
</div>
</div>
"""
return pn.pane.HTML(chart_html, sizing_mode='stretch_width')
# Create the chart using matplotlib if available
try:
import matplotlib.pyplot as plt
import io
import base64
price_data = self.key_metrics['price_by_distance']
plt.style.use('seaborn-v0_8-whitegrid')
fig, ax = plt.subplots(figsize=(8, 4), dpi=80)
fig.patch.set_facecolor('#F8F9FA')
ax.set_facecolor('#F8F9FA')
correct_order = ['0-200m', '200-400m', '400-600m', '600-800m', '800m+']
distances = [d for d in correct_order if d in price_data]
if not distances:
return pn.pane.Markdown("No property price data available by distance")
prices = [price_data[d] for d in distances]
bars = ax.bar(
distances,
prices,
color=theme['primary'],
alpha=0.7,
width=0.7,
edgecolor='white'
)
for bar in bars:
height = bar.get_height()
ax.text(
bar.get_x() + bar.get_width()/2.,
height * 1.01,
f'£{int(height):,}',
ha='center',
va='bottom',
fontsize=8,
rotation=0,
fontweight='bold'
)
ax.set_xlabel('Distance from Station')
ax.set_ylabel('Average Price (£)')
ax.set_title('Property Prices by Distance to Station')
ax.get_yaxis().set_major_formatter(
plt.matplotlib.ticker.FuncFormatter(lambda x, p: f'£{int(x):,}')
)
for spine in ax.spines.values():
spine.set_visible(False)
plt.tight_layout()
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=80, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
return pn.pane.HTML(
f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 5px;">',
sizing_mode='stretch_width'
)
except Exception as e:
print(f"Error creating property chart with matplotlib: {e}")
# Fall back to text-based display
summary_text = "### Property Prices by Distance to Station\n\n"
for distance in correct_order:
if distance in price_data:
summary_text += f"- **{distance}**: £{int(price_data[distance]):,}\n"
return pn.pane.Markdown(
summary_text,
styles=dict(
background=theme['secondary'],
padding='10px',
border_radius='5px',
border_left=f'4px solid {theme["primary"]}'
)
)
except Exception as e:
print(f"Error creating property chart: {e}")
return pn.pane.Markdown("Unable to create property price chart")
def _create_zone_distribution(self, theme):
"""Create a zone distribution chart"""
try:
if 'zone_distribution' not in self.key_metrics or not self.key_metrics['zone_distribution']:
# Create placeholder when the data is unavailable
chart_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 300px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 48px; color: {theme['primary']};">train</span>
<p style="margin-top: 10px;">Zone distribution data not available</p>
<p style="font-size: 0.9em; opacity: 0.7;">Please ensure station data is loaded</p>
</div>
</div>
"""
return pn.pane.HTML(chart_html, sizing_mode='stretch_width')
zone_data = self.key_metrics['zone_distribution']
if not zone_data:
return pn.pane.Markdown("No zone data available")
# Create chart using matplotlib if available
try:
import matplotlib.pyplot as plt
import io
import base64
zones = sorted(zone_data.keys(), key=lambda x: float(x) if x.isdigit() else float(x.split('/')[0]))
counts = [zone_data[z] for z in zones]
plt.style.use('seaborn-v0_8-whitegrid')
fig, ax = plt.subplots(figsize=(8, 4), dpi=80)
fig.patch.set_facecolor('#F8F9FA')
ax.set_facecolor('#F8F9FA')
cmap = plt.cm.get_cmap('viridis')
colors = [cmap(i/len(zones)) for i in range(len(zones))]
bars = ax.bar(
zones,
counts,
color=colors,
alpha=0.8,
width=0.7,
edgecolor='white'
)
for bar in bars:
height = bar.get_height()
ax.text(
bar.get_x() + bar.get_width()/2.,
height * 1.01,
str(int(height)),
ha='center',
va='bottom',
fontsize=9,
fontweight='bold'
)
ax.set_xlabel('Zone')
ax.set_ylabel('Number of Stations')
ax.set_title('Station Distribution by Zone')
for spine in ax.spines.values():
spine.set_visible(False)
plt.tight_layout()
buffer = io.BytesIO()
plt.savefig(buffer, format='png', dpi=80, bbox_inches='tight')
buffer.seek(0)
img = base64.b64encode(buffer.getvalue()).decode('utf-8')
plt.close(fig)
return pn.pane.HTML(
f'<img src="data:image/png;base64,{img}" width="100%" style="border-radius: 5px;">',
sizing_mode='stretch_width'
)
except Exception as e:
print(f"Error creating zone chart with matplotlib: {e}")
# Fall back to the text-based display
summary_text = "### Station Distribution by Zone\n\n"
for zone, count in sorted(zone_data.items(), key=lambda x: float(x[0]) if x[0].isdigit() else float(x[0].split('/')[0])):
summary_text += f"- **Zone {zone}**: {count} stations\n"
return pn.pane.Markdown(
summary_text,
styles=dict(
background=theme['secondary'],
padding='10px',
border_radius='5px',
border_left=f'4px solid {theme["primary"]}'
)
)
except Exception as e:
print(f"Error creating zone chart: {e}")
return pn.pane.Markdown("Unable to create zone distribution chart")
def _create_map_view(self, filtered_boroughs, theme):
"""Create an interactive map with borough and station data"""
try:
# Create placeholder for map view if required functions aren't available
if 'create_map' not in globals() or 'folium' not in globals():
map_html = f"""
<div style="background-color: {theme['secondary']}; border-radius: 5px; padding: 20px; text-align: center; height: 600px; display: flex; align-items: center; justify-content: center;">
<div>
<span class="material-icons" style="font-size: 64px; color: {theme['primary']};">map</span>
<h3>Interactive Map View</h3>
<p style="margin-top: 10px;">This view requires additional libraries: folium, matplotlib</p>
<p style="font-size: 0.9em; opacity: 0.7;">Please install required libraries to enable map visualizations</p>
</div>
</div>
"""
return pn.pane.HTML(map_html, sizing_mode='stretch_width')
if self.socioeconomic_indicator not in filtered_boroughs.columns:
return pn.pane.Markdown(
f"Error: Selected indicator '{self.socioeconomic_indicator}' not found in data. Please select another indicator.",
styles=dict(color='red', background='#FFEBEE', padding='10px', border_radius='5px')
)
if filtered_boroughs.empty:
return pn.pane.Markdown(
"No data available for the selected borough filter.",
styles=dict(color='red', background='#FFEBEE', padding='10px', border_radius='5px')
)
m = create_map()
# Add choropleth layer for boroughs
all_values = filtered_boroughs[self.socioeconomic_indicator].dropna()
if len(all_values) == 0:
return pn.pane.Markdown("No data available for the selected indicator.")
vmin, vmax = all_values.min(), all_values.max()
colormap = cm.get_cmap('viridis')
for idx, row in filtered_boroughs.iterrows():
value = row.get(self.socioeconomic_indicator, 0)
norm_value = (value - vmin) / (vmax - vmin) if vmax > vmin else 0.5
rgba_color = colormap(norm_value)
hex_color = mcolors.rgb2hex(rgba_color)
tooltip_html = f"""
<div style="font-family: Arial; max-width: 300px;">
<h4 style="margin: 0;">{row['name']}</h4>
<hr style="margin: 5px 0;">
<p><strong>{self.socioeconomic_indicator}:</strong> {value}</p>
"""
for metric in ['Station_Count', 'Station_Density', 'Transit_Accessibility_Index']:
if metric in row and pd.notnull(row[metric]):
if metric == 'Station_Count':
tooltip_html += f"<p><strong>Station Count:</strong> {int(row[metric])}</p>"
elif metric == 'Station_Density':
tooltip_html += f"<p><strong>Station Density:</strong> {row[metric]:.2f} stations/km²</p>"
else:
tooltip_html += f"<p><strong>{metric.replace('_', ' ')}:</strong> {row[metric]:.2f}</p>"
tooltip_html += "</div>"
folium.GeoJson(
row['geometry'].__geo_interface__,
style_function=lambda x, hex_color=hex_color: {
'fillColor': hex_color,
'color': '#263238',
'weight': 1,
'fillOpacity': 0.7
},
tooltip=folium.Tooltip(tooltip_html, sticky=True)
).add_to(m)
# Filter stations by zone if zones are selected
try:
if 'stations_gdf' in globals():
if self.station_zone_filter and 'Zone' in stations_gdf.columns:
filtered_stations = stations_gdf[
stations_gdf['Zone'].astype(str).str.contains('|'.join(self.station_zone_filter))
]
else:
filtered_stations = stations_gdf
if 'add_station_markers' in globals():
add_station_markers(m, filtered_stations)
else:
# Add basic markers if custom function isn't available
station_cluster = MarkerCluster(name="Transit Stations")
for _, station in filtered_stations.iterrows():
folium.CircleMarker(
location=[station.geometry.y, station.geometry.x],
radius=3,
color='blue',
fill=True,
fill_opacity=0.7,
tooltip=station.get('NAME', 'Station')
).add_to(station_cluster)
m.add_child(station_cluster)
except Exception as e:
print(f"Error adding station markers: {e}")
# Try to add property heatmap
try:
if 'property_gdf' in globals() and 'Distance_To_Station' in property_gdf.columns:
min_dist, max_dist = self.property_distance_filter
filtered_properties = property_gdf[
(property_gdf['Distance_To_Station'] >= min_dist) &
(property_gdf['Distance_To_Station'] <= max_dist)
].head(500) # Limit to 500 properties for performance
if 'add_property_heatmap' in globals():
add_property_heatmap(m, filtered_properties)
else:
# Create basic heatmap if custom function isn't available
from folium.plugins import HeatMap
heat_data = [[point.geometry.y, point.geometry.x] for idx, point in filtered_properties.iterrows()]
HeatMap(heat_data, name="Property Density").add_to(m)
except Exception as e:
print(f"Error adding property heatmap: {e}")
folium.LayerControl().add_to(m)
# Add legend
try:
legend_html = f"""
<div style="position: fixed;
bottom: 50px; right: 50px; z-index: 1000;
background-color: white;
padding: 10px; border-radius: 5px;
border: 1px solid grey;
opacity: 0.8;
font-family: Arial, sans-serif;">
<p style="margin-top: 0; margin-bottom: 5px; font-weight: bold;">{self.socioeconomic_indicator}</p>
<div style="display: flex; align-items: center; margin-bottom: 3px;">
<div style="width: 20px; height: 20px; background-color: {mcolors.rgb2hex(colormap(0))}; margin-right: 5px;"></div>
<span>{vmin:.2f}</span>
</div>
<div style="display: flex; align-items: center; margin-bottom: 3px;">
<div style="width: 20px; height: 20px; background-color: {mcolors.rgb2hex(colormap(0.5))}; margin-right: 5px;"></div>
<span>{(vmin + vmax) / 2:.2f}</span>
</div>
<div style="display: flex; align-items: center; margin-bottom: 3px;">
<div style="width: 20px; height: 20px; background-color: {mcolors.rgb2hex(colormap(1))}; margin-right: 5px;"></div>
<span>{vmax:.2f}</span>
</div>
</div>
"""
m.get_root().html.add_child(folium.Element(legend_html))
except Exception as e:
print(f"Error adding legend: {e}")
return pn.Column(
pn.pane.Markdown(
f"""
## Interactive Map: {self.socioeconomic_indicator}
This map shows the spatial distribution of {self.socioeconomic_indicator} across London boroughs.
Transit stations are shown as blue markers (clustered for better visibility). Property density is
visualized as a heatmap for properties within your selected distance range.
**Interact with the map:** Hover over boroughs for details, click station clusters to expand them,
and use the layer control in the top right to toggle different map elements.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
),
pn.pane.HTML(m._repr_html_(), height=600, sizing_mode='stretch_width'),
sizing_mode='stretch_width'
)
except Exception as e:
print(f"Error creating map view: {e}")
return pn.pane.Markdown(
f"Error creating map visualization: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_chart_view(self, filtered_boroughs, theme):
"""Create charts based on the selected chart type"""
try:
if self.socioeconomic_indicator not in filtered_boroughs.columns:
return pn.pane.Markdown(
f"Error: Selected indicator '{self.socioeconomic_indicator}' not found in data. Please select another indicator.",
styles=dict(color='red', background='#FFEBEE', padding='10px', border_radius='5px')
)
if filtered_boroughs.empty:
return pn.pane.Markdown(
"No data available for the selected borough filter.",
styles=dict(color='red', background='#FFEBEE', padding='10px', border_radius='5px')
)
if self.chart_type == 'Scatter':
return self._create_scatter_charts(filtered_boroughs, theme)
elif self.chart_type == 'Bar':
return self._create_bar_charts(filtered_boroughs, theme)
elif self.chart_type == 'Correlation':
return self._create_correlation_charts(filtered_boroughs, theme)
else:
return pn.pane.Markdown("Select a chart type")
except Exception as e:
print(f"Error creating chart view: {e}")
return pn.pane.Markdown(
f"Error creating chart visualization: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_scatter_charts(self, filtered_boroughs, theme):
"""Create scatter plots showing relationships between indicators"""
try:
# Check if the necessary library functions exist or not
if 'create_alt_scatter_chart' not in globals():
# Create the placeholder text if the visualization functions aren't available
scatter_info = f"""
## Transit Accessibility vs {self.socioeconomic_indicator}
The 'create_alt_scatter_chart' function is necessary for this visualization.
With a regression line and correlation coefficient, the scatter plot would display the relationship between
each borough's transit accessibility and {self.socioeconomic_indicator.lower()}
for each borough, with a regression line and correlation coefficient.
To enable this visualization, please define the required visualization functions.
"""
return pn.pane.Markdown(
scatter_info,
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
)
if 'Transit_Accessibility_Index' not in filtered_boroughs.columns:
return pn.pane.Markdown(
"Transit Accessibility Index not found in data",
styles=dict(color='red', background='#FFEBEE', padding='10px', border_radius='5px')
)
main_chart = pn.Column(
pn.pane.Markdown(
f"""
## Transit Accessibility vs {self.socioeconomic_indicator}
This scatter plot shows the relationship between transit accessibility and {self.socioeconomic_indicator.lower()}
for each borough. The red line shows the linear regression trend, and the correlation coefficient (r)
indicates the strength and direction of the relationship.
**Interpreting the correlation:**
- Values close to 1 indicate a strong positive relationship
- Values close to -1 indicate a strong negative relationship
- Values close to 0 indicate little or no relationship
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
),
create_alt_scatter_chart(
filtered_boroughs,
'Transit_Accessibility_Index',
self.socioeconomic_indicator,
color_col='Zone_Category' if 'Zone_Category' in filtered_boroughs.columns else None,
title=f"Transit Accessibility Index vs {self.socioeconomic_indicator}"
),
sizing_mode='stretch_width'
)
property_charts = pn.Column(sizing_mode='stretch_width')
try:
if 'property_data' in globals() and 'Distance_Band' in property_data.columns and 'Price' in property_data.columns:
min_dist, max_dist = self.property_distance_filter
filtered_properties = property_data[
(property_data['Distance_To_Station'] >= min_dist) &
(property_data['Distance_To_Station'] <= max_dist)
]
if not filtered_properties.empty and 'create_alt_bar_chart' in globals():
price_by_distance = (
filtered_properties
.groupby('Distance_Band')['Price']
.agg(['mean', 'count'])
.reset_index()
)
price_by_distance['mean'] = price_by_distance['mean'].round(0)
if len(price_by_distance) > 0:
property_charts.append(
pn.pane.Markdown(
"""
## Property Prices by Distance to Station
This chart shows how property prices vary with distance from transit stations.
Properties closer to stations typically command a premium, which is quantified
by comparing average prices across different distance bands.
The chart includes the sample size for each distance band, providing context
on the data distribution.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='30px 0 15px 0',
border_left=f'4px solid {theme["primary"]}'
)
)
)
property_charts.append(
create_alt_bar_chart(
price_by_distance,
'Distance_Band',
'mean',
title="Average Property Price by Distance to Station"
)
)
sample_info = ", ".join([f"{row['Distance_Band']}: {int(row['count']):,} properties" for _, row in price_by_distance.iterrows()])
property_charts.append(
pn.pane.Markdown(
f"**Sample Sizes:** {sample_info}",
styles=dict(font_size='0.9em', color='#666', margin='5px 0 0 0')
)
)
except Exception as e:
print(f"Error creating property charts: {e}")
return pn.Column(
main_chart,
property_charts,
sizing_mode='stretch_width'
)
except Exception as e:
print(f"Error creating scatter charts: {e}")
return pn.pane.Markdown(
f"Error creating scatter charts: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_bar_charts(self, filtered_boroughs, theme):
"""Create bar charts for borough comparisons"""
try:
# Check if the necessary library functions exist
if 'create_alt_bar_chart' not in globals():
# Create the placeholder text if visualization functions aren't available
bar_info = f"""
## Top Boroughs by {self.socioeconomic_indicator}
This visualization requires the 'create_alt_bar_chart' function.
The bar chart would show the top 15 London boroughs ranked by {self.socioeconomic_indicator.lower()}.
To enable this visualization, please define the required visualization functions.
"""
return pn.pane.Markdown(
bar_info,
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
)
if self.socioeconomic_indicator in filtered_boroughs.columns:
if filtered_boroughs.empty:
return pn.pane.Markdown("No data available for the selected borough filter")
sorted_boroughs = filtered_boroughs.sort_values(
by=self.socioeconomic_indicator,
ascending=False
).head(15) # Limit to top 15 for readability
main_chart = pn.Column(
pn.pane.Markdown(
f"""
## Top Boroughs by {self.socioeconomic_indicator}
This chart ranks the top 15 London boroughs by {self.socioeconomic_indicator.lower()}.
The ranking provides insights into which areas have the highest values for this indicator.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
),
create_alt_bar_chart(
sorted_boroughs,
'name',
self.socioeconomic_indicator,
title=f"Top Boroughs by {self.socioeconomic_indicator}"
),
sizing_mode='stretch_width'
)
if 'Station_Density' in sorted_boroughs.columns:
try:
station_sorted = filtered_boroughs.sort_values(
by='Station_Density',
ascending=False
).head(15)
secondary_chart = pn.Column(
pn.pane.Markdown(
"""
## Boroughs by Station Density
Boroughs are ranked according to the density of transit stations (stations per square kilometer) in this chart.
In general, greater density denotes better accessibility and coverage of public transportation.
To see how station density and socioeconomic indicators relate to one another, compare this ranking with the one above.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='30px 0 15px 0',
border_left=f'4px solid {theme["primary"]}'
)
),
create_alt_bar_chart(
station_sorted,
'name',
'Station_Density',
title="Top Boroughs by Transit Station Density"
),
sizing_mode='stretch_width'
)
if len(filtered_boroughs) >= 10:
try:
common_boroughs = set(sorted_boroughs['name']) & set(station_sorted['name'])
if common_boroughs:
rank_comparison = []
for borough in common_boroughs:
idx1 = sorted_boroughs[sorted_boroughs['name'] == borough].index[0]
idx2 = station_sorted[station_sorted['name'] == borough].index[0]
rank1 = sorted_boroughs.index.get_loc(idx1) + 1
rank2 = station_sorted.index.get_loc(idx2) + 1
rank_comparison.append(f"{borough}: #{rank1} vs #{rank2}")
rank_text = ", ".join(rank_comparison[:3])
if len(rank_comparison) > 3:
rank_text += f", and {len(rank_comparison) - 3} more"
secondary_chart.append(
pn.pane.Markdown(
f"**Ranking Comparison:** {rank_text}",
styles=dict(font_size='0.9em', color='#666', margin='5px 0 0 0')
)
)
except Exception as e:
print(f"Error calculating rank correlation: {e}")
return pn.Column(main_chart, secondary_chart, sizing_mode='stretch_width')
except Exception as e:
print(f"Error creating station density chart: {e}")
return main_chart
else:
return pn.pane.Markdown(
"Selected indicator not available in data",
styles=dict(color='red', background='#FFEBEE', padding='10px', border_radius='5px')
)
except Exception as e:
print(f"Error creating bar charts: {e}")
return pn.pane.Markdown(
f"Error creating bar charts: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_correlation_charts(self, filtered_boroughs, theme):
"""Create correlation analysis charts"""
try:
# Check if the correlation visualization functions are available or not.
if 'create_correlation_heatmap' not in globals() or 'create_alt_scatter_chart' not in globals():
# Create the placeholder text if visualization functions aren't available
corr_info = """
## Correlation Analysis
The 'create_correlation_heatmap' and 'create_alt_scatter_chart' functions are necessary for this visualization.
A scatter plot of the strongest relationships and a heatmap of correlations between socioeconomic indicators
would be displayed by the correlation analysis.
Please specify the necessary visualization functions in order to activate this visualization.
"""
return pn.pane.Markdown(
corr_info,
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
)
corr_columns = [
'Transit_Accessibility_Index', 'Station_Density', 'Station_Count',
'Social_Mobility_Score', 'Average_Income', 'Higher_Education_Rate',
'Unemployment_Rate', 'Deprivation_Score', 'Average_House_Price'
]
available_columns = [col for col in corr_columns if col in filtered_boroughs.columns]
if len(available_columns) > 1 and len(filtered_boroughs) > 1:
corr_matrix = filtered_boroughs[available_columns].corr().round(2)
heatmap = create_correlation_heatmap(
filtered_boroughs,
available_columns,
title="Correlation Matrix of Socioeconomic Indicators"
)
if 'Transit_Accessibility_Index' in corr_matrix.columns:
transit_corrs = corr_matrix['Transit_Accessibility_Index'].drop('Transit_Accessibility_Index')
strongest_corr = transit_corrs.abs().idxmax()
scatter_plot = create_alt_scatter_chart(
filtered_boroughs,
'Transit_Accessibility_Index',
strongest_corr,
title=f"Transit Accessibility vs {strongest_corr} (r={corr_matrix.loc['Transit_Accessibility_Index', strongest_corr]:.2f})"
)
corr_summary = []
for col in available_columns:
if col != 'Transit_Accessibility_Index' and 'Transit_Accessibility_Index' in corr_matrix.columns:
corr_value = corr_matrix.loc['Transit_Accessibility_Index', col]
if abs(corr_value) > 0.7:
strength = "Strong"
elif abs(corr_value) > 0.3:
strength = "Moderate"
else:
strength = "Weak"
direction = "positive" if corr_value > 0 else "negative"
corr_summary.append({
'Indicator': col,
'Correlation': corr_value,
'Relationship': f"{strength} {direction}"
})
corr_summary = sorted(corr_summary, key=lambda x: abs(x['Correlation']), reverse=True)
corr_table_html = f"""
<div style="padding: 15px; border-radius: 5px; background: white; margin-top: 15px; box-shadow: 0 1px 3px rgba(0,0,0,0.1);">
<h3 style="margin-top: 0; color: {theme['text']};">Correlation Summary</h3>
<p>This table summarizes the correlations between Transit Accessibility Index and other indicators:</p>
<table style="width: 100%; border-collapse: collapse; margin-top: 10px;">
<tr style="background: {theme['secondary']}; font-weight: bold;">
<th style="padding: 8px; text-align: left; border-bottom: 1px solid #ddd;">Indicator</th>
<th style="padding: 8px; text-align: center; border-bottom: 1px solid #ddd;">Correlation</th>
<th style="padding: 8px; text-align: left; border-bottom: 1px solid #ddd;">Relationship</th>
</tr>
"""
for i, item in enumerate(corr_summary):
bg_color = "#f9f9f9" if i % 2 == 0 else "white"
if item['Correlation'] > 0:
corr_color = "#2E7D32" # Green for positive
else:
corr_color = "#C62828" # Red for negative
corr_table_html += f"""
<tr style="background: {bg_color};">
<td style="padding: 8px; border-bottom: 1px solid #ddd;">{item['Indicator']}</td>
<td style="padding: 8px; text-align: center; border-bottom: 1px solid #ddd; font-weight: bold; color: {corr_color};">
{item['Correlation']:.2f}
</td>
<td style="padding: 8px; border-bottom: 1px solid #ddd;">{item['Relationship']}</td>
</tr>
"""
corr_table_html += """
</table>
</div>
"""
return pn.Column(
pn.pane.Markdown(
"""
## Correlation Analysis of Socioeconomic Indicators
This heatmap shows correlations between transit accessibility and socioeconomic factors.
Values closer to 1 or -1 indicate stronger relationships. Positive values (blue) show positive
correlation, while negative values (red) show inverse relationships.
**Interpreting the heatmap:**
- Blue cells indicate positive correlation: as one variable increases, the other tends to increase
- Red cells indicate negative correlation: as one variable increases, the other tends to decrease
- Darker colors indicate stronger correlations
- Values are between -1 (perfect negative correlation) and 1 (perfect positive correlation)
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
),
heatmap,
pn.pane.HTML(corr_table_html, sizing_mode='stretch_width'),
pn.pane.Markdown(
f"""
## Strongest Correlation: Transit Accessibility vs {strongest_corr}
This scatter plot shows the strongest correlation identified in the data.
The correlation coefficient (r={corr_matrix.loc['Transit_Accessibility_Index', strongest_corr]:.2f})
indicates a {"strong" if abs(corr_matrix.loc['Transit_Accessibility_Index', strongest_corr]) > 0.7 else "moderate" if abs(corr_matrix.loc['Transit_Accessibility_Index', strongest_corr]) > 0.3 else "weak"}
{"positive" if corr_matrix.loc['Transit_Accessibility_Index', strongest_corr] > 0 else "negative"} relationship.
Each point represents a borough, and the red line shows the overall trend.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='30px 0 15px 0',
border_left=f'4px solid {theme["primary"]}'
)
),
scatter_plot,
sizing_mode='stretch_width'
)
else:
return pn.Column(
pn.pane.Markdown(
"""
## Correlation Analysis of Socioeconomic Indicators
Correlations between socioeconomic factors across London boroughs are displayed in this heatmap.
Stronger relationships are indicated by values nearer 1 or -1.
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
),
heatmap,
sizing_mode='stretch_width'
)
return pn.pane.Markdown(
"""
**Insufficient data for correlation analysis**
At least two rows of data and two numeric columns are needed for correlation analysis.
Try adding more socioeconomic indicators or choosing a different borough filter.
""",
styles=dict(
background='#FFF8E1',
padding='15px',
border_radius='5px',
border_left='4px solid #FFC107'
)
)
except Exception as e:
print(f"Error creating correlation charts: {e}")
return pn.pane.Markdown(
f"Error creating correlation charts: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_data_tables(self, filtered_boroughs, theme):
"""Create data tables for detailed analysis"""
try:
# Check if the data table function is available or not.
if 'create_tabulator_table' not in globals():
# Create the placeholder text if function isn't available
table_info = """
## Data Tables View
The 'create_tabulator_table' function is necessary for this visualization.
In searchable, sortable tables, the data tables view would display comprehensive borough data,
property transaction data, and station information.
Please define the necessary table function in order to enable this visualization.
"""
return pn.pane.Markdown(
table_info,
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
)
if len(filtered_boroughs) > 0:
display_columns = ['name']
for col in ['Station_Count', 'Station_Density', 'Transit_Accessibility_Index',
'Social_Mobility_Score', self.socioeconomic_indicator]:
if col in filtered_boroughs.columns and col not in display_columns:
display_columns.append(col)
borough_table = create_tabulator_table(
filtered_boroughs[display_columns].round(2),
title="Borough Data",
height=400
)
tables = pn.Column(
pn.pane.Markdown(
"""
## Borough Data Table
This table provides detailed data for each borough. You can sort columns by clicking the headers
and filter data using the text boxes below each header.
**Tips for using the table:**
- Click column headers to sort ascending/descending
- Use the filter boxes below each header to filter data
- Adjust page size and navigate using controls at the bottom
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin_bottom='15px',
border_left=f'4px solid {theme["primary"]}'
)
),
borough_table,
sizing_mode='stretch_width'
)
# Property table
try:
if 'property_data' in globals() and len(property_data) > 0:
min_dist, max_dist = self.property_distance_filter
filtered_properties = property_data[
(property_data['Distance_To_Station'] >= min_dist) &
(property_data['Distance_To_Station'] <= max_dist)
].head(100)
if len(filtered_properties) > 0:
property_table = create_tabulator_table(
filtered_properties.round(2),
title="Property Data",
height=400
)
tables.append(
pn.pane.Markdown(
"""
## Property Transaction Data
This table shows property transactions with distance to nearest station.
Data is filtered based on your selected distance range (showing up to 100 records).
**Table Columns:**
- **Price**: Property transaction value in GBP
- **Distance_To_Station**: Distance to nearest station in meters
- **Distance_Band**: Categorized distance bands for easier analysis
- **Station_Premium_Pct**: Price premium compared to properties 600-800m from stations
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='30px 0 15px 0',
border_left=f'4px solid {theme["primary"]}'
)
)
)
tables.append(property_table)
except Exception as e:
print(f"Error creating property table: {e}")
# Station table
try:
if 'stations_data' in globals() and len(stations_data) > 0:
if self.station_zone_filter and 'Zone' in stations_data.columns:
filtered_stations = stations_data[
stations_data['Zone'].astype(str).str.contains('|'.join(self.station_zone_filter))
]
else:
filtered_stations = stations_data
filtered_stations = filtered_stations.head(100)
if len(filtered_stations) > 0:
station_table = create_tabulator_table(
filtered_stations,
title="Station Data",
height=400
)
tables.append(
pn.pane.Markdown(
"""
## Transit Station Data
This table shows information about transit stations in London.
Data is filtered based on your selected station zones (showing up to 100 records).
**Table Columns:**
- **NAME**: Station name
- **Zone**: Transit fare zone(s)
- **LINES**: Transit lines serving the station
- **EASTING/NORTHING**: Geographic coordinates in British National Grid
- **x/y**: Geographic coordinates in WGS84 (latitude/longitude)
""",
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='30px 0 15px 0',
border_left=f'4px solid {theme["primary"]}'
)
)
)
tables.append(station_table)
except Exception as e:
print(f"Error creating station table: {e}")
return tables
else:
return pn.pane.Markdown(
"No data available for selected filters. Try adjusting your borough selection.",
styles=dict(
background='#FFF8E1',
padding='15px',
border_radius='5px',
border_left='4px solid #FFC107'
)
)
except Exception as e:
print(f"Error creating data tables: {e}")
return pn.pane.Markdown(
f"Error creating data tables: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
def _create_insights_view(self, filtered_boroughs, theme):
"""Create an insights view with key takeaways and analysis"""
try:
insights_panel = pn.Column(
pn.pane.Markdown(
"""
# Key Insights & Analysis: Transit Accessibility in London
This page offers an analytical summary of the correlation between different socioeconomic
indicators across London boroughs and transit accessibility.
""",
styles=dict(
color=theme['text'],
font_size='24px',
margin_bottom='20px'
)
),
sizing_mode='stretch_width'
)
# Add transit accessibility summary
insights_panel.append(
pn.pane.Markdown(
f"""
## 1. Transit Accessibility Distribution London has {self.key_metrics.get('total_stations', 0)}
transit stations distributed across {self.key_metrics.get('total_boroughs', 0)} boroughs,
with an average of {self.key_metrics.get('avg_stations_per_borough', 0):.1f} stations per borough.
The borough with the highest transit accessibility index is **{self.key_metrics.get('best_transit_borough', 'N/A')}**
with a score of {self.key_metrics.get('best_transit_score', 0):.2f}.
Transit stations are concentrated in central London boroughs, with station density
decreasing as you move outward.
The difference between central and outer boroughs is substantial - central boroughs have up to
{self.key_metrics.get('max_stations', 0):.0f} stations, while some outer boroughs have as few as
{self.key_metrics.get('min_stations', 0):.0f} stations.
This spatial pattern has implications for equity in transport access, as residents in outer boroughs
typically experience longer travel times and fewer public transport options.
""",
styles=dict(
background='#E3F2FD',
padding='20px',
border_radius='10px',
margin='10px 0',
box_shadow='0 2px 4px rgba(0,0,0,0.1)'
)
)
)
# Add the property price insights if it's available or not.
if self.key_metrics.get('avg_property_price', 0) > 0:
insights_panel.append(
pn.pane.Markdown(
f"""
## 2. Property Prices and Transit Access
Properties near transit stations command a premium of approximately
**{self.key_metrics.get('station_proximity_premium', 0):.1f}%** compared to those farther away (600-800m).
The average property price in the dataset is £{self.key_metrics.get('avg_property_price', 0):,.0f}.
Zones 1-2 typically have higher property values, while outer zones tend to have lower values.
This price premium for transit-accessible properties has several implications:
* **Housing Affordability**: The costlier locations that are accessible by transit may make affordability issues worse.
* **Value Capture Potential**: Transit infrastructure raises the value of nearby real estate, opening doors for value-capture financing.
* **Development Incentives**: Transit-oriented development is encouraged by higher property values close to stations.
* **Equity Considerations**: Property owners may benefit disproportionately from investments in transit.
""",
styles=dict(
background='#FFEBEE',
padding='20px',
border_radius='10px',
margin='20px 0',
box_shadow='0 2px 4px rgba(0,0,0,0.1)'
)
)
)
# Add the correlation insights if it's available or not.
if 'strongest_positive_corr' in self.key_metrics:
pos_indicator, pos_value = self.key_metrics['strongest_positive_corr']
neg_indicator, neg_value = self.key_metrics['strongest_negative_corr']
correlation_text = f"""
## 3. Socioeconomic Correlations
Transit accessibility shows the strongest positive correlation with **{pos_indicator}**
(r={pos_value:.2f}).
"""
if neg_indicator != "None":
correlation_text += f"\nConversely, it has the strongest negative correlation with **{neg_indicator}** (r={neg_value:.2f})."
correlation_text += """
These correlations imply that socioeconomic outcomes and transit infrastructure are closely related,
but correlation by itself cannot establish causation. Some possible interpretations are as follows:
- Better job access through transit accessibility may lead to better socioeconomic outcomes.
- Greater transit investment may be attracted to areas with stronger socioeconomic indicators.
- There may be other underlying factors that impact both socioeconomic factors and transit access.
- These connections have been established over time by historical development patterns.
More advanced statistical techniques, longitudinal analysis, and case studies of transit system expansions
could all be used in future research to examine these relationships.
"""
insights_panel.append(
pn.pane.Markdown(
correlation_text,
styles=dict(
background='#E8F5E9',
padding='20px',
border_radius='10px',
margin='20px 0',
box_shadow='0 2px 4px rgba(0,0,0,0.1)'
)
)
)
# Add the methodological notes
insights_panel.append(
pn.pane.Markdown(
"""
## 4. Methodology Notes
### Transit Accessibility Index
A composite score (1–10) known as the Transit Accessibility Index is derived from the following:
- Station count within borough
- Station density (stations per km²)
Better transit access is indicated by higher values. In order to facilitate cross-borough comparisons, the index is normalized.
### Data Limitations
- In order to conceal intra-borough differences, socioeconomic data is aggregated at the borough level.
- Service frequency and transit quality are not taken into consideration in this analysis.
- Distance to the station is taken into account in property data, but other factors influencing property values are not.
- Relationships are shown by correlation analysis, but causality cannot be established.
### Interpretation Guidance
Correlation is not the same as causality. Economic trends, policy choices, and historical development patterns
are just a few of the variables that could have an impact on the relationships seen. The interpretation of these
results should take into account alternative explanations.
""",
styles=dict(
background='#F5F5F5',
padding='20px',
border_radius='10px',
margin='20px 0',
box_shadow='0 2px 4px rgba(0,0,0,0.1)'
)
)
)
# Add the policy implications section
insights_panel.append(
pn.pane.Markdown(
"""
## 5. Potential Policy Implications
The data analysis leads to the following policy considerations:
1. **Transit-Oriented Development** - Putting money into transit infrastructure could boost economic growth and property values.
2. **Equity Considerations** - In places with lower socioeconomic indicators, making transit accessible could encourage social mobility.
3. **Urban Planning Integration** - Socioeconomic benefits could be maximized by coordinating housing development and transit.
4. **Property Value Capture** - It may be possible to use the premium on properties close to stations to finance transit upgrades.
5. **Affordable Housing Near Transit** - Policies that preserve or expand affordable housing close to transportation can guarantee fair access.
6. **Service Quality Improvements** - Putting more emphasis on service dependability and frequency than station presence.
7. **Multi-Modal Integration** - Linking transit to walking, bicycling, and other environmentally friendly forms of transportation.
In addition to other urban planning and transportation goals,
these policy implications should be taken into account while keeping the local context and community needs in mind.
""",
styles=dict(
background='#FFF8E1',
padding='20px',
border_radius='10px',
margin='20px 0',
box_shadow='0 2px 4px rgba(0,0,0,0.1)'
)
)
)
# Add the references section
insights_panel.append(
pn.pane.Markdown(
"""
## 6. Further Research & References
This analysis provides a high-level overview of transit accessibility patterns across London.
Further research could explore:
* Using natural experiments or quasi-experimental techniques to establish causality.
* Changes in socioeconomic indicators and transit accessibility over time.
* Micro-level analysis at the census tract or neighborhood level.
* Comparing other cities around the world.
### Relevant Literature
* Cervero, R., & Kang, C. D. (2011). "Bus rapid transit impacts on land uses and land values in Seoul, Korea."
* Mulley, C., et al. (2016). "Residential property value impacts of proximity to transport infrastructure."
* Cao, X. J., & Porter-Nelson, D. (2016). "Real estate development in anticipation of the Green Line light rail transit in St. Paul."
* Higgins, C. D., & Kanaroglou, P. S. (2016). "A latent class method for classifying and evaluating the performance of station area transit-oriented development in the Toronto region."
""",
styles=dict(
background='#EDE7F6',
padding='20px',
border_radius='10px',
margin='20px 0',
box_shadow='0 2px 4px rgba(0,0,0,0.1)'
)
)
)
return insights_panel
except Exception as e:
print(f"Error creating insights view: {e}")
return pn.pane.Markdown(
f"Error creating insights analysis: {e}",
styles=dict(
background='#FFEBEE',
padding='10px',
border_radius='5px',
border_left='4px solid #C62828'
)
)
@param.depends('socioeconomic_indicator', 'color_theme')
def _create_correlation_table(self):
"""Create a table showing correlations with transit accessibility"""
try:
theme = self.theme_colors[self.color_theme]
if self.visualization_mode in ['Data Tables', 'Insights & Analysis']:
return pn.pane.Markdown("")
# Check if we have the correlation data or not?
if 'correlations' in self.key_metrics and self.key_metrics['correlations']:
correlation_data = self.key_metrics['correlations']
corr_items = []
for indicator, corr_value in correlation_data.items():
if indicator == self.socioeconomic_indicator:
relationship = "Strong positive" if corr_value > 0.7 else \
"Moderate positive" if corr_value > 0.3 else \
"Weak positive" if corr_value > 0 else \
"Strong negative" if corr_value < -0.7 else \
"Moderate negative" if corr_value < -0.3 else \
"Weak negative"
corr_items.append(f"- **{indicator}**: {corr_value:.2f} ({relationship})")
else:
corr_items.append(f"- {indicator}: {corr_value:.2f}")
if corr_items:
return pn.pane.Markdown(
"### Correlation with Transit Accessibility\n" + "\n".join(corr_items),
styles=dict(
background=theme['secondary'],
padding='15px',
border_radius='5px',
margin='15px 0',
border_left=f'4px solid {theme["primary"]}'
)
)
return pn.pane.Markdown("")
except Exception as e:
print(f"Error creating correlation table: {e}")
return pn.pane.Markdown("")
def show(self):
"""Display the dashboard"""
return self.dashboard
# ==========================================================
# 4. DASHBOARD DISPLAY
# ==========================================================
# Import the Material Design Icons for the modern UI elements
pn.extension('materialize')
# Create and configure the enhanced dashboard
dashboard = TransitDashboard()
# Set up the custom CSS for better styling
custom_css = """
body {
font-family: 'Roboto', 'Segoe UI', 'Arial', sans-serif;
}
.bk-root .bk-btn-default {
background-color: #3F51B5;
border-color: #3F51B5;
color: white;
border-radius: 4px;
font-weight: 500;
transition: background-color 0.3s ease;
}
.bk-root .bk-btn-default:hover {
background-color: #303F9F;
box-shadow: 0 2px 5px rgba(0,0,0,0.2);
}
.sidebar {
border-radius: 10px;
box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
background-color: #F5F7FA;
}
.bk-root .slick-cell.selected {
background-color: #E8EAF6;
}
.bk-root .bk-tab {
color: #3F51B5;
border-radius: 4px 4px 0 0;
padding: 8px 16px;
font-weight: 500;
}
.bk-root .bk-tab.bk-active {
background-color: #E8EAF6;
border-color: #3F51B5;
}
.material-icons {
font-family: 'Material Icons';
font-weight: normal;
font-style: normal;
font-size: 24px;
line-height: 1;
letter-spacing: normal;
text-transform: none;
display: inline-block;
white-space: nowrap;
word-wrap: normal;
direction: ltr;
-webkit-font-feature-settings: 'liga';
-webkit-font-smoothing: antialiased;
}
/* Custom scrollbar for a modern look */
::-webkit-scrollbar {
width: 8px;
height: 8px;
}
::-webkit-scrollbar-track {
background: #f1f1f1;
border-radius: 10px;
}
::-webkit-scrollbar-thumb {
background: #c1c1c1;
border-radius: 10px;
}
::-webkit-scrollbar-thumb:hover {
background: #a1a1a1;
}
/* Improved table styling */
.bk-root .slick-header-column {
background-color: #E8EAF6;
color: #3F51B5;
font-weight: bold;
border-right: 1px solid #D1D1D1;
}
.bk-root .slick-row:hover {
background-color: #F5F5F5;
}
/* Add animation for smoother transitions */
.bk-root .bk-tab, .bk-root .bk-btn-default {
transition: all 0.2s ease;
}
/* Make RadioBoxGroup buttons look better */
.bk-root .bk-btn-group .bk-btn {
border-radius: 0;
}
.bk-root .bk-btn-group .bk-btn:first-child {
border-radius: 4px 0 0 4px;
}
.bk-root .bk-btn-group .bk-btn:last-child {
border-radius: 0 4px 4px 0;
}
"""
# Apply the custom CSS
pn.config.raw_css.append(custom_css)
# Add the Material Icons CSS
material_icons_css = """
@import url('https://fonts.googleapis.com/icon?family=Material+Icons');
@import url('https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap');
"""
pn.config.raw_css.append(material_icons_css)
# Add this line at the very end of your script
dashboard.show()
Loading data from files... Loaded 471 transit stations
WARNING:param.panel_extension: materialize extension not recognized and will be skipped.
Data preparation complete.
Out[79]:
An advanced data visualization tool called the London Transit Accessibility Dashboard looks at the connections between socioeconomic characteristics and public transportation accessibility in different London boroughs. In order to maintain functionality, the application generates synthetic data when needed and loads data from transit stations, borough boundaries, socioeconomic indicators, and real estate transactions. With a contemporary Material Design aesthetic, the dashboard showcases a variety of visualization formats, such as interactive maps, scatter plots, bar charts, correlation heatmaps, and data tables.
Built using a comprehensive class-based architecture, the TransitDashboard class manages state, calculates metrics, and handles user interactions through parameter objects. Users can filter data by borough, station zone, and property distance, while exploring different visualization modes (Overview, Map, Charts, Tables, Analysis) and color themes. The dashboard employs event-driven programming to update visualizations dynamically when selections change, with responsive design principles ensuring proper display across different devices. Error handling mechanisms gracefully manage data processing challenges, while detailed tooltips and legends enhance information accessibility.
This powerful analysis tool effectively demonstrates how Python libraries—Panel, Folium, Matplotlib, and various data analysis packages—can create an elegant interface for exploring urban transit accessibility patterns and their socioeconomic implications.RetryClaude can make mistakes. Please double-check responses.
Conclusion¶
Socioeconomic outcomes across boroughs are significantly correlated with the accessibility of public transport, according to our analysis of London's transit system. Transportation accessibility and social mobility were found to be strongly positively correlated (r = 0.804), with central boroughs having higher socioeconomic indicators and better transit access. The economic benefit of being close to a transit station is measured by the 24.4% price premium that properties within 200 meters of it command. Our statistical analyses and visualizations have revealed distinct spatial patterns that show how important transportation infrastructure is in forming urban socioeconomic landscapes. Despite the need for complementary housing policies to address affordability concerns, these findings imply that strategic transit investments may be able to drive economic opportunity.
References¶
- Andersson, F., Haltiwanger, J.C., Kutzbach, M.J., Pollakowski, H.O. and Weinberg, D.H., 2018. Job displacement and the duration of joblessness: The role of spatial mismatch. Review of Economics and Statistics, 100(2), pp.203-218.
- Blumenberg, E. and Pierce, G., 2017. Car access and long-term poverty exposure: Evidence from the Moving to Opportunity (MTO) experiment. Journal of transport geography, 65, pp.92-100.
- Cervero, R. and Kang, C.D., 2011. Bus rapid transit impacts on land uses and land values in Seoul, Korea. Transport policy, 18(1), pp.102-116.
- Chetty, R. and Hendren, N., 2018. The impacts of neighborhoods on intergenerational mobility I: Childhood exposure effects. The quarterly journal of economics, 133(3), pp.1107-1162.
- Higgins, C.D. and Kanaroglou, P.S., 2016. Forty years of modelling rapid transit’s land value uplift in North America: Moving beyond the tip of the iceberg. Transport Reviews, 36(5), pp.610-634.
- Kaufman, S., Moss, M.L., Tyndall, J. and Hernandez, J., 2014. Mobility, economic opportunity and New York City neighborhoods. NYU Wagner Research Paper, (2598566).
- Merlin, L.A., Singer, M. and Levine, J., 2021. Influences on transit ridership and transit accessibility in US urban areas. Transportation Research Part A: Policy and Practice, 150, pp.63-73.
- Mulley, C., Ma, L., Clifton, G., Yen, B. and Burke, M., 2016. Residential property value impacts of proximity to transport infrastructure: An investigation of bus rapid transit and heavy rail networks in Brisbane, Australia. Journal of Transport Geography, 54, pp.41-52.
- Nie, Y., Bhatnagar, S., Smith, D. and Suel, E., 2024. Disparities in public transport accessibility in London from 2011 to 2021. Computers, Environment and Urban Systems, 113, p.102169.
- Olsson, L.E., Friman, M. and Lättman, K., 2021. Accessibility barriers and perceived accessibility: Implications for public transport. Urban Science, 5(3), p.63.
- Sanchez, T.W., 1999. The connection between public transit and employment: The cases of Portland and Atlanta. Journal of the American Planning Association, 65(3), pp.284-296.
- Thomopoulos, N., Grant-Muller, S. and Tight, M.R., 2009. Incorporating equity considerations in transport infrastructure evaluation: Current practice and a proposed methodology. Evaluation and program planning, 32(4), pp.351-359.
Youtube Video Link is: https://youtu.be/-8Glow8y9og¶
In [ ]: